Biocontainers

Link to section 'What is BioContainers' of 'Biocontainers' What is BioContainers

biocontainer_workflow

The BioContainers project came from the idea of using the containers-based technologies such as Docker or rkt for bioinformatics software. Having a common and controllable environment for running software could help to deal with some of the current problems during software development and distribution. BioContainers is a community-driven project that provides the infrastructure and basic guidelines to create, manage and distribute bioinformatics containers with a special focus on omics fields such as proteomics, genomics, transcriptomics and metabolomics. . For more information, please visit BioContainers project.

Link to section 'Deployed Applications' of 'Biocontainers' Deployed Applications

abacas

Link to section 'Introduction' of 'abacas' Introduction

Abacas is a tool for algorithm based automatic contiguation of assembled sequences.

For more information, please check its website: https://biocontainers.pro/tools/abacas and its home page: http://abacas.sourceforge.net.

Link to section 'Versions' of 'abacas' Versions

1.3.1

Link to section 'Commands' of 'abacas' Commands

abacas.pl
abacas.1.3.1.pl

Link to section 'Module' of 'abacas' Module

You can load the modules by:

module load biocontainers
module load abacas

Link to section 'Example job' of 'abacas' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Abacas on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=abacas
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers abacas

abacas.pl -r cmm.fasta -q Cm.contigs.fasta -p nucmer -o out_prefix

abismal

Link to section 'Introduction' of 'abismal' Introduction

Another Bisulfite Mapping Algorithm (abismal) is a read mapping program for bisulfite sequencing in DNA methylation studies.

BioContainers: https://biocontainers.pro/tools/abismal
Home page: https://github.com/smithlabcode/abismal

Link to section 'Versions' of 'abismal' Versions

3.0.0

Link to section 'Commands' of 'abismal' Commands

abismal
abismalidx
simreads

Link to section 'Module' of 'abismal' Module

You can load the modules by:

module load biocontainers
module load abismal

Link to section 'Example job' of 'abismal' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run abismal on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=abismal
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers abismal

abismalidx  ~/.local/share/genomes/hg38/hg38.fa hg38

abpoa

Link to section 'Introduction' of 'abpoa' Introduction

abPOA: adaptive banded Partial Order Alignment

Home page: https://github.com/yangao07/abPOA

Link to section 'Versions' of 'abpoa' Versions

1.4.1

Link to section 'Commands' of 'abpoa' Commands

abpoa

Link to section 'Module' of 'abpoa' Module

You can load the modules by:

module load biocontainers
module load abpoa

Link to section 'Example job' of 'abpoa' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run abpoa on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=abpoa
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers abpoa

abpoa seq.fa > cons.fa

abricate

Link to section 'Introduction' of 'abricate' Introduction

Abricate is a tool for mass screening of contigs for antimicrobial resistance or virulence genes.

For more information, please check its website: https://biocontainers.pro/tools/abricate and its home page on Github.

Link to section 'Versions' of 'abricate' Versions

1.0.1

Link to section 'Commands' of 'abricate' Commands

abricate

Link to section 'Module' of 'abricate' Module

You can load the modules by:

module load biocontainers
module load abricate

Link to section 'Example job' of 'abricate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Abricate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=abricate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers abricate

abricate --threads 8 *.fasta

abyss

Link to section 'Introduction' of 'abyss' Introduction

ABySS is a de novo sequence assembler intended for short paired-end reads and genomes of all sizes.

For more information, please check its website: https://biocontainers.pro/tools/abyss and its home page on Github.

Link to section 'Versions' of 'abyss' Versions

2.3.2
2.3.4
2.3.8

Link to section 'Module' of 'abyss' Module

You can load the modules by:

module load biocontainers
module load abyss

Link to section 'Example job' of 'abyss' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run abyss on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=abyss
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers abyss

abyss-pe np=4 k=25 name=test B=1G \
    in='test-data/reads1.fastq test-data/reads2.fastq'

actc

Link to section 'Introduction' of 'actc' Introduction

Actc is used to align subreads to ccs reads.

Home page: https://github.com/PacificBiosciences/actc

Link to section 'Versions' of 'actc' Versions

0.2.0

Link to section 'Commands' of 'actc' Commands

actc

Link to section 'Module' of 'actc' Module

You can load the modules by:

module load biocontainers
module load actc

Link to section 'Example job' of 'actc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run actc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=actc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers actc

actc subreads.bam ccs.bam subreads_to_ccs.bam

adapterremoval

Link to section 'Introduction' of 'adapterremoval' Introduction

AdapterRemoval searches for and removes adapter sequences from High-Throughput Sequencing (HTS) data and (optionally) trims low quality bases from the 3' end of reads following adapter removal. AdapterRemoval can analyze both single end and paired end data, and can be used to merge overlapping paired-ended reads into (longer) consensus sequences. Additionally, AdapterRemoval can construct a consensus adapter sequence for paired-ended reads, if which this information is not available.

BioContainers: https://biocontainers.pro/tools/adapterremoval
Home page: https://github.com/MikkelSchubert/adapterremoval

Link to section 'Versions' of 'adapterremoval' Versions

2.3.3

Link to section 'Commands' of 'adapterremoval' Commands

AdapterRemoval

Link to section 'Module' of 'adapterremoval' Module

You can load the modules by:

module load biocontainers
module load adapterremoval

Link to section 'Example job' of 'adapterremoval' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run adapterremoval on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=adapterremoval
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers adapterremoval

AdapterRemoval --file1 input_1.fastq --file2 input_2.fastq

advntr

Link to section 'Introduction' of 'advntr' Introduction

Advntr is a tool for genotyping Variable Number Tandem Repeats (VNTR) from sequence data.

For more information, please check its website: https://biocontainers.pro/tools/advntr and its home page on Github.

Link to section 'Versions' of 'advntr' Versions

1.4.0
1.5.0

Link to section 'Commands' of 'advntr' Commands

advntr

Link to section 'Module' of 'advntr' Module

You can load the modules by:

module load biocontainers
module load advntr

Link to section 'Example job' of 'advntr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Advntr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=advntr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers advntr

advntr addmodel -r chr21.fa -p CGCGGGGCGGGG -s 45196324 -e 45196360 -c chr21
advntr genotype --vntr_id 1 --alignment_file CSTB_2_5_testdata.bam --working_directory working_dir

afplot

Link to section 'Introduction' of 'afplot' Introduction

Afplot is a tool to plot allele frequencies in VCF files.

For more information, please check its website: https://biocontainers.pro/tools/afplot and its home page on Github.

Link to section 'Versions' of 'afplot' Versions

0.2.1

Link to section 'Commands' of 'afplot' Commands

afplot

Link to section 'Module' of 'afplot' Module

You can load the modules by:

module load biocontainers
module load afplot

Link to section 'Example job' of 'afplot' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run afplot on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=afplot
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers afplot

afplot whole-genome histogram -v my_vcf.gz -l my_label -s my_sample -o mysample.histogram.png

afterqc

Link to section 'Introduction' of 'afterqc' Introduction

Afterqc is a tool for quality control of FASTQ data produced by HiSeq 2000/2500/3000/4000, Nextseq 500/550, MiniSeq, and Illumina 1.8 or newer.

For more information, please check its website: https://biocontainers.pro/tools/afterqc and its home page on Github.

Link to section 'Versions' of 'afterqc' Versions

0.9.7

Link to section 'Commands' of 'afterqc' Commands

after.py

Link to section 'Module' of 'afterqc' Module

You can load the modules by:

module load biocontainers
module load afterqc

Link to section 'Example job' of 'afterqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run blobtools on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=afterqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers afterqc

after.py -1 SRR11941281_1.fastq.paired.fq  -2 SRR11941281_2.fastq.paired.fq

agat

Link to section 'Introduction' of 'agat' Introduction

Agat is a suite of tools to handle gene annotations in any GTF/GFF format.

For more information, please check its website: https://biocontainers.pro/tools/agat and its home page on Github.

Link to section 'Versions' of 'agat' Versions

0.8.1

Link to section 'Module' of 'agat' Module

You can load the modules by:

module load biocontainers
module load agat

Link to section 'Example job' of 'agat' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Agat on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=agat
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers agat

agat_convert_sp_gff2bed.pl  --gff genes.gff -o genes.bed

agfusion

Link to section 'Introduction' of 'agfusion' Introduction

AGFusion (pronounced 'A G Fusion') is a python package for annotating gene fusions from the human or mouse genomes.

Docker hub: https://hub.docker.com/r/mgibio/agfusion
Home page: https://github.com/murphycj/AGFusion

Link to section 'Versions' of 'agfusion' Versions

1.3.11

Link to section 'Commands' of 'agfusion' Commands

agfusion

Link to section 'Module' of 'agfusion' Module

You can load the modules by:

module load biocontainers
module load agfusion

Link to section 'Example job' of 'agfusion' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run agfusion on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=agfusion
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers agfusion

alfred

Link to section 'Introduction' of 'alfred' Introduction

Alfred is an efficient and versatile command-line application that computes multi-sample quality control metrics in a read-group aware manner.

For more information, please check its website: https://biocontainers.pro/tools/alfred and its home page on Github.

Link to section 'Versions' of 'alfred' Versions

0.2.5
0.2.6

Link to section 'Commands' of 'alfred' Commands

alfred

Link to section 'Module' of 'alfred' Module

You can load the modules by:

module load biocontainers
module load alfred

Link to section 'Example job' of 'alfred' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Alfred on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=alfred
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers alfred

alfred qc -r genome.fasta -o qc.tsv.gz sorted.bam

alien-hunter

Link to section 'Introduction' of 'alien-hunter' Introduction

Alien-hunter is an application for the prediction of putative Horizontal Gene Transfer (HGT) events with the implementation of Interpolated Variable Order Motifs (IVOMs).

For more information, please check its website: https://biocontainers.pro/tools/alien-hunter.

Link to section 'Versions' of 'alien-hunter' Versions

1.7.7

Link to section 'Commands' of 'alien-hunter' Commands

alien_hunter

Link to section 'Module' of 'alien-hunter' Module

You can load the modules by:

module load biocontainers
module load alien_hunter

Link to section 'Example job' of 'alien-hunter' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Alien_hunter on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=alien_hunter
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers alien_hunter
 
alien_hunter genome.fasta output

alignstats

Link to section 'Introduction' of 'alignstats' Introduction

AlignStats produces various alignment, whole genome coverage, and capture coverage metrics for sequence alignment files in SAM, BAM, and CRAM format.

BioContainers: https://biocontainers.pro/tools/alignstats
Home page: https://github.com/jfarek/alignstats

Link to section 'Versions' of 'alignstats' Versions

0.9.1

Link to section 'Commands' of 'alignstats' Commands

alignstats

Link to section 'Module' of 'alignstats' Module

You can load the modules by:

module load biocontainers
module load alignstats

Link to section 'Example job' of 'alignstats' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run alignstats on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=alignstats
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers alignstats

alignstats -C -i input.bam -o report.txt

allpathslg

Link to section 'Introduction' of 'allpathslg' Introduction

Allpathslg is a whole-genome shotgun assembler that can generate high-quality genome assemblies using short reads.

For more information, please check its website: https://biocontainers.pro/tools/allpathslg and its home page: https://bioinformaticshome.com/tools/wga/descriptions/Allpaths-LG.html.

Link to section 'Versions' of 'allpathslg' Versions

52488

Link to section 'Commands' of 'allpathslg' Commands

PrepareAllPathsInputs.pl
RunAllPathsLG
CacheLibs.pl
Fasta2Fastb

Link to section 'Module' of 'allpathslg' Module

You can load the modules by:

module load biocontainers
module load allpathslg

Link to section 'Example job' of 'allpathslg' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Allpathslg on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=allpathslg
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers allpathslg

PrepareAllPathsInputs.pl \
                       DATA_DIR=data \
                       PLOIDY=1 \
                       IN_GROUPS_CSV=in_groups.csv\
                       IN_LIBS_CSV=in_libs.csv\
                       OVERWRITE=True\

RunAllPathsLG PRE=allpathlg REFERENCE_NAME=test.genome \
              DATA_SUBDIR=data  RUN=myrun TARGETS=standard \
              SUBDIR=test OVERWRITE=True

alphafold

Link to section 'Introduction' of 'alphafold' Introduction

Alphafold is a protein structure prediction tool developed by DeepMind (Google). It uses a novel machine learning approach to predict 3D protein structures from primary sequences alone. The source code is available on Github. It has been deployed in all RCAC clusters, supporting both CPU and GPU.

It also relies on a huge database. The full database ( 2.2TB) has been downloaded and setup for users.

Protein struction prediction by alphafold is performed in the following steps:

Search the amino acid sequence in uniref90 database by jackhmmer (using CPU)
Search the amino acid sequence in mgnify database by jackhmmer (using CPU)
Search the amino acid sequence in pdb70 database (for monomers) or pdb_seqres database (for multimers) by hhsearch (using CPU)
Search the amino acid sequence in bfd database and uniclust30 (updated to uniref30 since v2.3.0) database by hhblits (using CPU)
Search structure templates in pdb_mmcif database (using CPU)
Search the amino acid sequence in uniprot database (for multimers) by jackhmmer (using CPU)
Predict 3D structure by machine learning (using CPU or GPU)
Structure optimisation with OpenMM (using CPU or GPU)

Link to section 'Versions' of 'alphafold' Versions

2.1.1
2.2.0
2.2.3
2.3.0
2.3.1
2.3.2

Link to section 'Commands' of 'alphafold' Commands

run_alphafold.sh

Link to section 'Module' of 'alphafold' Module

You can load the modules by:

module load biocontainers
module load alphafold

Link to section 'Usage' of 'alphafold' Usage

The usage of Alphafold on our cluster is very straightford, users can create a flagfile containing the database path information:

run_alphafold.sh --flagfile=full_db.ff --fasta_paths=XX --output_dir=XX ...

Users can check its detailed user guide in its Github.

Link to section 'full_db.ff' of 'alphafold' full_db.ff

Example contents of full_db.ff:

--db_preset=full_dbs
--bfd_database_path=/depot/itap/datasets/alphafold/db/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt
--data_dir=/depot/itap/datasets/alphafold/db/
--uniref90_database_path=/depot/itap/datasets/alphafold/db/uniref90/uniref90.fasta
--mgnify_database_path=/depot/itap/datasets/alphafold/db/mgnify/mgy_clusters_2018_12.fa
--uniclust30_database_path=/depot/itap/datasets/alphafold/db/uniclust30/uniclust30_2018_08/uniclust30_2018_08
--pdb70_database_path=/depot/itap/datasets/alphafold/db/pdb70/pdb70
--template_mmcif_dir=/depot/itap/datasets/alphafold/db/pdb_mmcif/mmcif_files
--max_template_date=2022-01-29
--obsolete_pdbs_path=/depot/itap/datasets/alphafold/db/pdb_mmcif/obsolete.dat
--hhblits_binary_path=/usr/bin/hhblits
--hhsearch_binary_path=/usr/bin/hhsearch
--jackhmmer_binary_path=/usr/bin/jackhmmer
--kalign_binary_path=/usr/bin/kalign

Since Version v2.2.0, the AlphaFold-Multimer model parameters has been updated. The updated full database is stored in depot/itap/datasets/alphafold/db_20221014. For ACCESS Anvil, the database is stored in /anvil/datasets/alphafold/db_20221014. Users need to update the flagfile using the updated database:

run_alphafold.sh --flagfile=full_db_20221014.ff --fasta_paths=XX --output_dir=XX ...

Link to section 'full_db_20221014.ff (for alphafold v2)' of 'alphafold' full_db_20221014.ff (for alphafold v2)

Example contents of full_db_20221014.ff (For ACCESS Anvil, please change depot/itap to anvil):

--db_preset=full_dbs
--bfd_database_path=/depot/itap/datasets/alphafold/db_20221014/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt
--data_dir=/depot/itap/datasets/alphafold/db_20221014/
--uniref90_database_path=/depot/itap/datasets/alphafold/db_20221014/uniref90/uniref90.fasta
--mgnify_database_path=/depot/itap/datasets/alphafold/db_20221014/mgnify/mgy_clusters_2018_12.fa
--uniclust30_database_path=/depot/itap/datasets/alphafold/db_20221014/uniclust30/uniclust30_2018_08/uniclust30_2018_08
--pdb_seqres_database_path=/depot/itap/datasets/alphafold/db_20221014/pdb_seqres/pdb_seqres.txt
--uniprot_database_path=/depot/itap/datasets/alphafold/db_20221014/uniprot/uniprot.fasta
--template_mmcif_dir=/depot/itap/datasets/alphafold/db_20221014/pdb_mmcif/mmcif_files
--obsolete_pdbs_path=/depot/itap/datasets/alphafold/db_20221014/pdb_mmcif/obsolete.dat
--hhblits_binary_path=/usr/bin/hhblits
--hhsearch_binary_path=/usr/bin/hhsearch
--jackhmmer_binary_path=/usr/bin/jackhmmer
--kalign_binary_path=/usr/bin/kalign

Since Version v2.3.0, the AlphaFold-Multimer model parameters has been updated. The updated full database is stored in depot/itap/datasets/alphafold/db_20230311. For ACCESS Anvil, the database is stored in /anvil/datasets/alphafold/db_20230311. Users need to update the flagfile using the updated database:

run_alphafold.sh --flagfile=full_db_20230311.ff --fasta_paths=XX --output_dir=XX ...

Since Version v2.3.0, uniclust30_database_path has been changed to uniref30_database_path.

Link to section 'full_db_20230311.ff (for alphafold v3)' of 'alphafold' full_db_20230311.ff (for alphafold v3)

Example contents of full_db_20230311.ff for monomer (For ACCESS Anvil, please change depot/itap to anvil):

--db_preset=full_dbs
--bfd_database_path=/depot/itap/datasets/alphafold/db_20230311/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt
--data_dir=/depot/itap/datasets/alphafold/db_20230311/
--uniref90_database_path=/depot/itap/datasets/alphafold/db_20230311/uniref90/uniref90.fasta
--mgnify_database_path=/depot/itap/datasets/alphafold/db_20230311/mgnify/mgy_clusters_2022_05.fa
--uniref30_database_path=/depot/itap/datasets/alphafold/db_20230311/uniref30/UniRef30_2021_03
--pdb70_database_path=/depot/itap/datasets/alphafold/db_20230311/pdb70/pdb70
--template_mmcif_dir=/depot/itap/datasets/alphafold/db_20230311/pdb_mmcif/mmcif_files
--obsolete_pdbs_path=/depot/itap/datasets/alphafold/db_20230311/pdb_mmcif/obsolete.dat
--hhblits_binary_path=/usr/bin/hhblits
--hhsearch_binary_path=/usr/bin/hhsearch
--jackhmmer_binary_path=/usr/bin/jackhmmer
--kalign_binary_path=/usr/bin/kalign

Example contents of full_db_20230311.ff for multimer (For ACCESS Anvil, please change depot/itap to anvil):

--db_preset=full_dbs
--bfd_database_path=/depot/itap/datasets/alphafold/db_20230311/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt
--data_dir=/depot/itap/datasets/alphafold/db_20230311/
--uniref90_database_path=/depot/itap/datasets/alphafold/db_20230311/uniref90/uniref90.fasta
--mgnify_database_path=/depot/itap/datasets/alphafold/db_20230311/mgnify/mgy_clusters_2022_05.fa
--uniref30_database_path=/depot/itap/datasets/alphafold/db_20230311/uniref30/UniRef30_2021_03
--pdb_seqres_database_path=/depot/itap/datasets/alphafold/db_20230311/pdb_seqres/pdb_seqres.txt
--uniprot_database_path=/depot/itap/datasets/alphafold/db_20230311/uniprot/uniprot.fasta
--template_mmcif_dir=/depot/itap/datasets/alphafold/db_20230311/pdb_mmcif/mmcif_files
--obsolete_pdbs_path=/depot/itap/datasets/alphafold/db_20230311/pdb_mmcif/obsolete.dat
--hhblits_binary_path=/usr/bin/hhblits
--hhsearch_binary_path=/usr/bin/hhsearch
--jackhmmer_binary_path=/usr/bin/jackhmmer
--kalign_binary_path=/usr/bin/kalign

Link to section 'Example job using CPU' of 'alphafold' Example job using CPU

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

Notice that since version 2.2.0, the parameter --use_gpu_relax=False is required.

To run alphafold using CPU:

#!/bin/bash
#SBATCH -A myallocation	# Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=alphafold
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers alphafold/2.3.1

run_alphafold.sh --flagfile=full_db_20230311.ff  \
    --fasta_paths=sample.fasta --max_template_date=2022-02-01 \
    --output_dir=af2_full_out --model_preset=monomer \
    --use_gpu_relax=False

Link to section 'Example job using GPU' of 'alphafold' Example job using GPU

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

Notice that since version 2.2.0, the parameter --use_gpu_relax=True is required.

To run alphafold using GPU:

#!/bin/bash
#SBATCH -A myallocation	# Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 11
#SBATCH --gres=gpu:1
#SBATCH --job-name=alphafold
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers alphafold/2.3.1

run_alphafold.sh --flagfile=full_db_20230311.ff \
    --fasta_paths=sample.fasta --max_template_date=2022-02-01 \
    --output_dir=af2_full_out --model_preset=monomer \
    --use_gpu_relax=True

amptk

Link to section 'Introduction' of 'amptk' Introduction

Amptk is a series of scripts to process NGS amplicon data using USEARCH and VSEARCH, it can also be used to process any NGS amplicon data and includes databases setup for analysis of fungal ITS, fungal LSU, bacterial 16S, and insect COI amplicons.

For more information, please check its website: https://biocontainers.pro/tools/amptk and its home page on Github.

Link to section 'Versions' of 'amptk' Versions

1.5.4

Link to section 'Commands' of 'amptk' Commands

amptk

Link to section 'Module' of 'amptk' Module

You can load the modules by:

module load biocontainers
module load amptk

Link to section 'Example job' of 'amptk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Amptk on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=amptk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers amptk

amptk illumina -i test_data/illumina_test_data -o miseq -f fITS7 -r ITS4  --cpus 4

ananse

Link to section 'Introduction' of 'ananse' Introduction

ANANSE is a computational approach to infer enhancer-based gene regulatory networks (GRNs) and to identify key transcription factors between two GRNs.

BioContainers: https://biocontainers.pro/tools/ananse
Home page: https://github.com/vanheeringen-lab/ANANSE

Link to section 'Versions' of 'ananse' Versions

0.4.0

Link to section 'Commands' of 'ananse' Commands

ananse

Link to section 'Module' of 'ananse' Module

You can load the modules by:

module load biocontainers
module load ananse

Link to section 'Example job' of 'ananse' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ananse on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ananse
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ananse

mkdir -p ANANSE.REMAP.model.v1.0
wget https://zenodo.org/record/4768075/files/ANANSE.REMAP.model.v1.0.tgz
tar xvzf ANANSE.REMAP.model.v1.0.tgz -C ANANSE.REMAP.model.v1.0
rm ANANSE.REMAP.model.v1.0.tgz

wget https://zenodo.org/record/4769814/files/ANANSE_example_data.tgz
tar xvzf ANANSE_example_data.tgz
rm ANANSE_example_data.tgz

ananse binding -H ANANSE_example_data/H3K27ac/fibroblast*bam -A ANANSE_example_data/ATAC/fibroblast*bam -R ANANSE.REMAP.model.v1.0/ -o fibroblast.binding
ananse binding -H ANANSE_example_data/H3K27ac/heart*bam -A ANANSE_example_data/ATAC/heart*bam -R ANANSE.REMAP.model.v1.0/ -o heart.binding

ananse network -b  fibroblast.binding/binding.h5 -e ANANSE_example_data/RNAseq/fibroblast*TPM.txt -n 4 -o fibroblast.network.txt
ananse network -b  heart.binding/binding.h5 -e ANANSE_example_data/RNAseq/heart*TPM.txt -n 4 -o heart.network.txt

ananse influence -s fibroblast.network.txt -t heart.network.txt -d ANANSE_example_data/RNAseq/fibroblast2heart_degenes.csv -p -o fibroblast2heart.influence.txt

anchorwave

Link to section 'Introduction' of 'anchorwave' Introduction

Anchorwave is used for sensitive alignment of genomes with high sequence diversity, extensive structural polymorphism and whole-genome duplication variation.

For more information, please check its website: https://biocontainers.pro/tools/anchorwave and its home page on Github.

Link to section 'Versions' of 'anchorwave' Versions

1.0.1
1.1.1

Link to section 'Commands' of 'anchorwave' Commands

anchorwave
gmap_build
gmap
minimap2

Link to section 'Module' of 'anchorwave' Module

You can load the modules by:

module load biocontainers
module load anchorwave

Link to section 'Example job' of 'anchorwave' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Anchorwave on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=anchorwave
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers anchorwave

anchorwave gff2seq -i Zea_mays.AGPv4.34.gff3 -r Zea_mays.AGPv4.dna.toplevel.fa -o cds.fa

angsd

ANGSD is a software for analyzing next generation sequencing data. Detailed usage can be found here: http://www.popgen.dk/angsd/index.php/ANGSD.

Link to section 'Versions' of 'angsd' Versions

0.935
0.937
0.939
0.940

Link to section 'Commands' of 'angsd' Commands

angsd
realSFS
msToGlf
thetaStat
supersim

Link to section 'Module' of 'angsd' Module

You can load the modules by:

module load biocontainers
module load angsd/0.937

Link to section 'Example job' of 'angsd' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run angsd on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=angsd
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers angsd/0.937

angsd -b bam.filelist -GL 1 -doMajorMinor 1 -doMaf 2 -P 5 -minMapQ 30 -minQ 20 -minMaf 0.05

annogesic

Link to section 'Introduction' of 'annogesic' Introduction

ANNOgesic is the swiss army knife for RNA-Seq based annotation of bacterial/archaeal genomes.

Docker hub: https://hub.docker.com/r/silasysh/annogesic
Home page: https://github.com/Sung-Huan/ANNOgesic

Link to section 'Versions' of 'annogesic' Versions

1.1.0

Link to section 'Commands' of 'annogesic' Commands

annogesic

Link to section 'Module' of 'annogesic' Module

You can load the modules by:

module load biocontainers
module load annogesic

Link to section 'Example job' of 'annogesic' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run annogesic on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=annogesic
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers annogesic

ANNOGESIC_FOLDER=ANNOgesic
annogesic \
    update_genome_fasta \
    -c $ANNOGESIC_FOLDER/input/references/fasta_files/NC_009839.1.fa \
    -m $ANNOGESIC_FOLDER/input/mutation_tables/mutation.csv \
    -u NC_test.1 \
    -pj $ANNOGESIC_FOLDER

annovar

Link to section 'Introduction' of 'annovar' Introduction

ANNOVAR is an efficient software tool to utilize update-to-date information to functionally annotate genetic variants detected from diverse genomes (including human genome hg18, hg19, hg38, as well as mouse, worm, fly, yeast and many others).

For more information, please check its website: https://annovar.openbioinformatics.org/en/latest/.

Link to section 'Versions' of 'annovar' Versions

2022-01-13

Link to section 'Commands' of 'annovar' Commands

annotate_variation.pl
coding_change.pl
convert2annovar.pl
retrieve_seq_from_fasta.pl
table_annovar.pl
variants_reduction.pl

Link to section 'Module' of 'annovar' Module

You can load the modules by:

module load biocontainers
module load annovar

Link to section 'Example job' of 'annovar' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ANNOVAR on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=annovar
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers annovar

annotate_variation.pl --buildver hg19 --downdb seq humandb/hg19_seq
convert2annovar.pl -format region -seqdir humandb/hg19_seq/ chr1:2000001-2000003

antismash

Link to section 'Introduction' of 'antismash' Introduction

Antismash Antismash allows the rapid genome-wide identification, annotation and analysis of secondary metabolite biosynthesis gene clusters in bacterial and fungal genomes.

For more information, please check its website: https://biocontainers.pro/tools/antismash and its home page: https://docs.antismash.secondarymetabolites.org.

Link to section 'Versions' of 'antismash' Versions

5.1.2
6.0.1
6.1.0

Link to section 'Commands' of 'antismash' Commands

antismash

Link to section 'Module' of 'antismash' Module

You can load the modules by:

module load biocontainers
module load antismash

Link to section 'Example job' of 'antismash' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Antismash on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=antismash
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers antismash 

antismash --cb-general --cb-knownclusters --cb-subclusters --asf --pfam2go --smcog-trees seq.gbk

anvio

Link to section 'Introduction' of 'anvio' Introduction

Anvio is an analysis and visualization platform for 'omics data.

For more information, please check its website: https://biocontainers.pro/tools/anvio and its home page on Github.

Link to section 'Versions' of 'anvio' Versions

7.0
7.1_main
7.1_structure

Link to section 'Module' of 'anvio' Module

You can load the modules by:

module load biocontainers
module load anvio

Link to section 'Example job' of 'anvio' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Anvio on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=anvio
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers anvio  
 
anvi-script-reformat-fasta assembly.fa -o contigs.fa -l 1000 --simplify-names  --seq-type NT
anvi-gen-contigs-database -f contigs.fa -o contigs.db -n 'An example contigs database' --num-threads 8
anvi-display-contigs-stats contigs.db
anvi-setup-ncbi-cogs --cog-data-dir $PWD --num-threads 8 --just-do-it --reset
anvi-run-ncbi-cogs -c contigs.db --cog-data-dir COG20 --num-threads 8

any2fasta

Link to section 'Introduction' of 'any2fasta' Introduction

Any2fasta can convert various sequence formats to FASTA.

BioContainers: https://biocontainers.pro/tools/any2fasta
Home page: https://github.com/tseemann/any2fasta

Link to section 'Versions' of 'any2fasta' Versions

0.4.2

Link to section 'Commands' of 'any2fasta' Commands

any2fasta

Link to section 'Module' of 'any2fasta' Module

You can load the modules by:

module load biocontainers
module load any2fasta

Link to section 'Example job' of 'any2fasta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run any2fasta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=any2fasta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers any2fasta

any2fasta input.gff > out.fasta

arcs

Link to section 'Introduction' of 'arcs' Introduction

ARCS is a tool for scaffolding genome sequence assemblies using linked or long read sequencing data.

Home page: https://github.com/bcgsc/arcs

Link to section 'Versions' of 'arcs' Versions

1.2.4

Link to section 'Commands' of 'arcs' Commands

arcs
arcs-make

Link to section 'Module' of 'arcs' Module

You can load the modules by:

module load biocontainers
module load arcs

Link to section 'Example job' of 'arcs' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run arcs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=arcs
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers arcs

asgal

Link to section 'Introduction' of 'asgal' Introduction

ASGAL (Alternative Splicing Graph ALigner) is a tool for detecting the alternative splicing events expressed in a RNA-Seq sample with respect to a gene annotation.

Docker hub: https://hub.docker.com/r/algolab/asgal and its home page on Github.

Link to section 'Versions' of 'asgal' Versions

1.1.7

Link to section 'Commands' of 'asgal' Commands

asgal

Link to section 'Module' of 'asgal' Module

You can load the modules by:

module load biocontainers
module load asgal

Link to section 'Example job' of 'asgal' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ASGAL on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=asgal
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers asgal

asgal -g input/genome.fa \
    -a input/annotation.gtf \
    -s input/sample_1.fa -o outputFolder

assembly-stats

Link to section 'Introduction' of 'assembly-stats' Introduction

Assembly-stats is a tool to get assembly statistics from FASTA and FASTQ files.

For more information, please check its website: https://biocontainers.pro/tools/assembly-stats and its home page on Github.

Link to section 'Versions' of 'assembly-stats' Versions

1.0.1

Link to section 'Commands' of 'assembly-stats' Commands

assembly-stats

Link to section 'Module' of 'assembly-stats' Module

You can load the modules by:

module load biocontainers
module load assembly-stats

Link to section 'Example job' of 'assembly-stats' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Assembly-stats on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 00:10:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=assembly-stats
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers assembly-stats

assembly-stats seq.fasta

atac-seq-pipeline

Link to section 'Introduction' of 'atac-seq-pipeline' Introduction

The ENCODE ATAC-seq pipeline is used for quality control and statistical signal processing of short-read sequencing data, producing alignments and measures of enrichment. It was developed by Anshul Kundaje's lab at Stanford University.

Docker hub: https://hub.docker.com/r/encodedcc/atac-seq-pipeline
Home page: https://www.encodeproject.org/atac-seq/

Link to section 'Versions' of 'atac-seq-pipeline' Versions

2.1.3

Link to section 'Module' of 'atac-seq-pipeline' Module

You can load the modules by:

module load biocontainers
module load atac-seq-pipeline

Link to section 'Example job' of 'atac-seq-pipeline' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run atac-seq-pipeline on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=atac-seq-pipeline
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers atac-seq-pipeline

ataqv

Link to section 'Introduction' of 'ataqv' Introduction

Ataqv is a toolkit for measuring and comparing ATAC-seq results, made in the Parker lab at the University of Michigan.

For more information, please check its website: https://biocontainers.pro/tools/ataqv and its home page on Github.

Link to section 'Versions' of 'ataqv' Versions

1.3.0

Link to section 'Commands' of 'ataqv' Commands

ataqv

Link to section 'Module' of 'ataqv' Module

You can load the modules by:

module load biocontainers
module load ataqv

Link to section 'Example job' of 'ataqv' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ataqv on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ataqv
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ataqv

ataqv --peak-file sample_1_peaks.broadPeak \
    --name sample_1 --metrics-file sample_1.ataqv.json.gz \
    --excluded-region-file hg19.blacklist.bed.gz \
    --tss-file hg19.tss.refseq.bed.gz \
    --ignore-read-groups human sample_1.md.bam \
     > sample_1.ataqv.out

ataqv --peak-file sample_2_peaks.broadPeak \
    --name sample_2 --metrics-file sample_2.ataqv.json.gz \
    --excluded-region-file hg19.blacklist.bed.gz \
    --tss-file hg19.tss.refseq.bed.gz \ 
    --ignore-read-groups human sample_2.md.bam \
    > sample_2.ataqv.out

ataqv --peak-file sample_3_peaks.broadPeak \
    --name sample_3 --metrics-file sample_3.ataqv.json.gz \
    --excluded-region-file hg19.blacklist.bed.gz \
    --tss-file hg19.tss.refseq.bed.gz \
    --ignore-read-groups human sample_3.md.bam \
     > sample_3.ataqv.out

mkarv my_fantastic_experiment sample_1.ataqv.json.gz sample_2.ataqv.json.gz sample_3.ataqv.json.gz

atram

aTRAM (automated target restricted assembly method) is an iterative assembler that performs reference-guided local de novo assemblies using a variety of available methods.

Detailed usage can be found here: https://bioinformaticshome.com/tools/wga/descriptions/aTRAM.html

Link to section 'Versions' of 'atram' Versions

2.4.3

Link to section 'Commands' of 'atram' Commands

atram.py
atram_preprocessor.py
atram_stitcher.py

Link to section 'Module' of 'atram' Module

You can load the modules by:

module load biocontainers
module load atram/2.4.3

Link to section 'Example job' of 'atram' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run aTRAM on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=atram
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers atram/2.4.3a

atram_preprocessor.py --blast-db=atram_db  \ 
                      --end-1=data/tutorial_end_1.fasta.gz \
                      --end-2=data/tutorial_end_2.fasta.gz \ 
                      --gzip
atram.py --query=tutorial-query.pep.fasta  \
         --blast-db=atram_db \
         --output=output \
         --assembler=velvet

atropos

Link to section 'Introduction' of 'atropos' Introduction

Atropos is a tool for specific, sensitive, and speedy trimming of NGS reads.

For more information, please check its website: https://biocontainers.pro/tools/atropos and its home page on Github.

Link to section 'Versions' of 'atropos' Versions

1.1.17
1.1.31

Link to section 'Commands' of 'atropos' Commands

atropos

Link to section 'Module' of 'atropos' Module

You can load the modules by:

module load biocontainers
module load atropos

Link to section 'Example job' of 'atropos' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Atropos on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=atropos
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers atropos

atropos --threads 4  \
    -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCACGAGTTA \
    -o trimmed1.fq.gz -p trimmed2.fq.gz \
    -pe1 SRR13176582_1.fastq -pe2 SRR13176582_2.fastq

augur

Link to section 'Introduction' of 'augur' Introduction

Augur is the bioinformatics toolkit we use to track evolution from sequence and serological data.

For more information, please check its website: https://biocontainers.pro/tools/augur and its home page on Github.

Link to section 'Versions' of 'augur' Versions

14.0.0
15.0.0

Link to section 'Commands' of 'augur' Commands

augur

Link to section 'Module' of 'augur' Module

You can load the modules by:

module load biocontainers
module load augur

Link to section 'Example job' of 'augur' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Augur on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=augur
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers augur

mkdir -p results
augur index --sequences zika-tutorial/data/sequences.fasta \
            --output results/sequence_index.tsv

augur filter --sequences zika-tutorial/data/sequences.fasta \
             --sequence-index results/sequence_index.tsv \
             --metadata  zika-tutorial/data/metadata.tsv \
             --exclude zika-tutorial/config/dropped_strains.txt \ 
             --output results/filtered.fasta \
             --group-by country year month \
             --sequences-per-group 20 \
             --min-date 2012

augur align --sequences results/filtered.fasta \ 
            --reference-sequence zika-tutorial/config/zika_outgroup.gb \
            --output results/aligned.fasta \
            --fill-gaps

augur tree --alignment results/aligned.fasta \
           --output results/tree_raw.nwk

augur refine --tree results/tree_raw.nwk \
             --alignment results/aligned.fasta \
             --metadata  zika-tutorial/data/metadata.tsv \
             --output-tree results/tree.nwk \
             --output-node-data results/branch_lengths.json \
             --timetree \
             --coalescent opt \
             --date-confidence \
             --date-inference marginal \
             --clock-filter-iqd 4

augustus

Link to section 'Introduction' of 'augustus' Introduction

AUGUSTUS is a program that predicts genes in eukaryotic genomic sequences.

For more information, please check its website: https://bioinf.uni-greifswald.de/augustus/.

Link to section 'Versions' of 'augustus' Versions

3.4.0
3.5.0

Commands
- aln2wig
- augustus
- bam2wig - bam2wig-dist - consensusFinder - curve2hints - etraining - fastBlockSearch - filterBam - getSeq - getSeq-dist - homGeneMapping - joingenes - prepareAlign

Link to section 'Module' of 'augustus' Module

You can load the modules by:

module load biocontainers
module load augustus/3.4.0

Link to section 'Example job' of 'augustus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run AUGUSTUS on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=AUGUSTUS
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers augustus/3.4.0 

augustus --species=botrytis_cinerea genome.fasta > annotation.gff

bactopia

Link to section 'Introduction' of 'bactopia' Introduction

Bactopia is a flexible pipeline for complete analysis of bacterial genomes. The goal of Bactopia is to process your data with a broad set of tools, so that you can get to the fun part of analyses quicker!

Docker hub: https://hub.docker.com/r/bactopia/bactopia
Home page: https://github.com/bactopia/bactopia

Link to section 'Versions' of 'bactopia' Versions

2.0.3
2.1.1
2.2.0
3.0.0

Link to section 'Commands' of 'bactopia' Commands

bactopia

Link to section 'Module' of 'bactopia' Module

You can load the modules by:

module load biocontainers
module load bactopia

Link to section 'Example job' of 'bactopia' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bactopia on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=bactopia
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bactopia

bactopia datasets \
--ariba "vfdb_core,card" \
--species "Staphylococcus aureus" \
--include_genus \
--limit 100 \
--cpus 12

bactopia --accession SRX4563634 \
--datasets datasets/ \
--species "Staphylococcus aureus" \
--coverage 100 \
--genome_size median \
--outdir ena-single-sample \
--max_cpus 12

bali-phy

Link to section 'Introduction' of 'bali-phy' Introduction

Bali-phy is a tool for bayesian co-estimation of phylogenies and multiple alignments via MCMC.

BioContainers: https://biocontainers.pro/tools/bali-phy
Home page: https://github.com/bredelings/BAli-Phy

Link to section 'Versions' of 'bali-phy' Versions

3.6.0

Link to section 'Commands' of 'bali-phy' Commands

bali-phy

Link to section 'Module' of 'bali-phy' Module

You can load the modules by:

module load biocontainers
module load bali-phy

Link to section 'Example job' of 'bali-phy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bali-phy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bali-phy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bali-phy

bali-phy examples/sequences/ITS/ITS1.fasta 5.8S.fasta ITS2.fasta --test
bali-phy examples/sequences/5S-rRNA/5d-clustalw.fasta -S gtr+Rates.gamma[4]+inv -n 5d-free

bam-readcount

Link to section 'Introduction' of 'bam-readcount' Introduction

Bam-readcount is a utility that runs on a BAM or CRAM file and generates low-level information about sequencing data at specific nucleotide positions.

Docker hub: https://hub.docker.com/r/mgibio/bam-readcount and its home page on Github.

Link to section 'Versions' of 'bam-readcount' Versions

1.0.0

Link to section 'Commands' of 'bam-readcount' Commands

bam-readcount

Link to section 'Module' of 'bam-readcount' Module

You can load the modules by:

module load biocontainers
module load bam-readcount

Link to section 'Example job' of 'bam-readcount' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bam-readcount on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bam-readcount
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bam-readcount

bam-readcount -f Homo_sapiens.GRCh38.dna.primary_assembly.fa Aligned.sortedByCoord.out.bam

bamgineer

Link to section 'Introduction' of 'bamgineer' Introduction

Bamgineer is a tool that can be used to introduce user-defined haplotype-phased allele-specific copy number variations (CNV) into an existing Binary Alignment Mapping (BAM) file with demonstrated applicability to simulate somatic cancer CNVs in phased whole-genome sequencing datasets.

Docker hub: https://hub.docker.com/r/suluxan/bamgineer-v2 and its home page on Github.

Link to section 'Versions' of 'bamgineer' Versions

Link to section 'Commands' of 'bamgineer' Commands

simulate.py

Link to section 'Module' of 'bamgineer' Module

You can load the modules by:

module load biocontainers
module load bamgineer

Link to section 'Example job' of 'bamgineer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bamgineer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bamgineer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bamgineer

simulate.py -config inputs/config.cfg \
            -splitbamdir splitbams \
            -cnv_bed inputs/cnv.bed \
            -vcf inputs/normal_het.vcf \
            -exons inputs/exons.bed \
            -outbam tumour.bam \
            -results outputs \
            -cancertype LUAC1

bamliquidator

Link to section 'Introduction' of 'bamliquidator' Introduction

Bamliquidator is a set of tools for analyzing the density of short DNA sequence read alignments in the BAM file format.

Docker hub: https://hub.docker.com/r/bioliquidator/bamliquidator/ and its home page on Github.

Link to section 'Versions' of 'bamliquidator' Versions

1.5.2

Link to section 'Commands' of 'bamliquidator' Commands

bamliquidator
bamliquidator_bins
bamliquidator_regions
bamliquidatorbatch

Link to section 'Module' of 'bamliquidator' Module

You can load the modules by:

module load biocontainers
module load bamliquidator

Link to section 'Example job' of 'bamliquidator' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bamliquidator on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bamliquidator
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bamliquidator

bamsurgeon

Link to section 'Introduction' of 'bamsurgeon' Introduction

Bamsurgeon are tools for adding mutations to .bam files, used for testing mutation callers.

Docker hub: https://hub.docker.com/r/lethalfang/bamsurgeon and its home page on Github.

Link to section 'Versions' of 'bamsurgeon' Versions

Link to section 'Commands' of 'bamsurgeon' Commands

addindel.py
addsnv.py
addsv.py

Link to section 'Module' of 'bamsurgeon' Module

You can load the modules by:

module load biocontainers
module load bamsurgeon

Link to section 'Example job' of 'bamsurgeon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bamsurgeon on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bamsurgeon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bamsurgeon

addsv.py -p 1 -v test_sv.txt -f testregion_realign.bam \
    -r reference.fasta -o testregion_sv_mut.bam \
    --aligner mem --keepsecondary --seed 1234 \
    --inslib test_inslib.fa

bamtools

Link to section 'Introduction' of 'bamtools' Introduction

BamTools is a programmer API and an end-user toolkit for handling BAM files. This container provides a toolkit-only version (no API to build against).

For more information, please check its website: https://biocontainers.pro/tools/bamtools and its home page on Github.

Link to section 'Versions' of 'bamtools' Versions

2.5.1

Link to section 'Commands' of 'bamtools' Commands

bamtools

Link to section 'Module' of 'bamtools' Module

You can load the modules by:

module load biocontainers
module load bamtools

Link to section 'Example job' of 'bamtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BamTools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bamtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH -ddd-error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bamtools

bamtools convert -format fastq -in in.bam -out out.fastq

bamutil

Link to section 'Introduction' of 'bamutil' Introduction

Bamutil is a collection of programs for working on SAM/BAM files.

For more information, please check its website: https://biocontainers.pro/tools/bamutil and its home page on Github.

Link to section 'Versions' of 'bamutil' Versions

1.0.15

Link to section 'Commands' of 'bamutil' Commands

Link to section 'Module' of 'bamutil' Module

You can load the modules by:

module load biocontainers
module load bamutil

Link to section 'Example job' of 'bamutil' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bamutil on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bamutil
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bamutil

bam validate --params --in test/testFiles/testInvalid.sam --refFile test/testFilesLibBam/chr1_partial.fa --v --noph 2> results/validateInvalid.txt

bam convert --params --in test/testFiles/testFilter.bam --out results/convertBam.sam --noph 2> results/convertBam.log

bam  splitChromosome --in test/testFile/sortedBam1.bam --out results/splitSortedBam --noph 2> results/splitChromosome.txt

bam stats --basic --in test/testFiles/testFilter.sam --noph 2> results/basicStats.txt 

bam gapInfo --in test/testFiles/testGapInfo.sam --out results/gapInfo.txt --noph 2> results/gapInfo.log

bam findCigars --in test/testFiles/testRevert.sam --out results/cigarNonM.sam --nonM --noph 2> results/cigarNonM.log

barrnap

Link to section 'Introduction' of 'barrnap' Introduction

Barrnap: BAsic Rapid Ribosomal RNA Predictor.

For more information, please check its website: https://biocontainers.pro/tools/barrnap and its home page on Github.

Link to section 'Versions' of 'barrnap' Versions

0.9.4

Link to section 'Commands' of 'barrnap' Commands

barrnap

Link to section 'Module' of 'barrnap' Module

You can load the modules by:

module load biocontainers
module load barrnap

Link to section 'Example job' of 'barrnap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Barrnap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=barrnap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers barrnap

barrnap --kingdom bac -o bac_16s.fasta < bac_genome.fasta > bac_16s.gff3
barrnap --kingdom euk -o euk_16s.fasta < euk_genome.fasta  > euk_16s.gff3

basenji

Link to section 'Introduction' of 'basenji' Introduction

Basenji is a tool for sequential regulatory activity predictions with deep convolutional neural networks.

For more information, please check its website: https://biocontainers.pro/tools/basenji and its home page on Github.

Link to section 'Versions' of 'basenji' Versions

0.5.1

Link to section 'Module' of 'basenji' Module

You can load the modules by:

module load biocontainers
module load basenji

Link to section 'Example job' of 'basenji' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Basenji on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=basenji
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers basenji

bazam

Link to section 'Introduction' of 'bazam' Introduction

Bazam is a tool to extract paired reads in FASTQ format from coordinate sorted BAM files. For more information, please check: Docker hub: https://hub.docker.com/r/dockanomics/bazam
Home page: https://github.com/ssadedin/bazam

Link to section 'Versions' of 'bazam' Versions

1.0.1

Link to section 'Commands' of 'bazam' Commands

bazam

Link to section 'Module' of 'bazam' Module

You can load the modules by:

module load biocontainers
module load bazam

Link to section 'Example job' of 'bazam' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bazam on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bazam
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bazam

bbmap

Link to section 'Introduction' of 'bbmap' Introduction

Bbmap is a short read aligner, as well as various other bioinformatic tools.

For more information, please check its website: https://biocontainers.pro/tools/bbmap and its home page on Sourceforge.

Link to section 'Versions' of 'bbmap' Versions

38.93
38.96

Link to section 'Module' of 'bbmap' Module

You can load the modules by:

module load biocontainers
module load bbmap

Link to section 'Example job' of 'bbmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bbmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bbmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bbmap

stats.sh in=SRR11234553_1.fastq > stats_out.txt
statswrapper.sh *.fastq > statswrapper_out.txt
pileup.sh in=map1.sam out=pileup_out.txt
readlength.sh in=SRR11234553_1.fastq in2=SRR11234553_2.fastq > readlength_out.txt
kmercountexact.sh in=SRR11234553_1.fastq in2=SRR11234553_2.fastq out=kmer_test.out khist=kmer.khist peaks=kmer.peak
bbmask.sh in=SRR11234553_1.fastq out=test.mark sam=map1.sam

bbtools

Link to section 'Introduction' of 'bbtools' Introduction

BBTools is a suite of fast, multithreaded bioinformatics tools designed for analysis of DNA and RNA sequence data.

Docker hub: https://hub.docker.com/r/staphb/bbtools
Home page: https://jgi.doe.gov/data-and-tools/software-tools/bbtools/

Link to section 'Versions' of 'bbtools' Versions

39.00

Link to section 'Module' of 'bbtools' Module

You can load the modules by:

module load biocontainers
module load bbtools

Link to section 'Example job' of 'bbtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bbtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bbtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bbtools

bcftools

Link to section 'Introduction' of 'bcftools' Introduction

Bcftools is a program for variant calling and manipulating files in the Variant Call Format (VCF) and its binary counterpart BCF.

For more information, please check its website: https://biocontainers.pro/tools/bcftools and its home page on Github.

Link to section 'Versions' of 'bcftools' Versions

1.13
1.14
1.17

Link to section 'Commands' of 'bcftools' Commands

bcftools
color-chrs.pl
guess-ploidy.py
plot-roh.py
plot-vcfstats
run-roh.pl
vcfutils.pl

Link to section 'Module' of 'bcftools' Module

You can load the modules by:

module load biocontainers
module load bcftools

Link to section 'Example job' of 'bcftools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bcftools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bcftools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bcftools

bcftools query -f '%CHROM %POS %REF %ALT\n' file.bcf
bcftools polysomy -v -o outdir/ file.vcf
   
# Variant calling
bcftools mpileup -f reference.fa alignments.bam | bcftools call -mv -Ob -o calls.bcf

bcl2fastq

Link to section 'Introduction' of 'bcl2fastq' Introduction

bcl2fastq Conversion Software both demultiplexes data and converts BCL files generated by Illumina sequencing systems to standard FASTQ file formats for downstream analysis.

Docker hub: https://hub.docker.com/r/gcfntnu/bcl2fastq
Home page: https://support.illumina.com/sequencing/sequencing_software/bcl2fastq-conversion-software.html

Link to section 'Versions' of 'bcl2fastq' Versions

2.20.0

Link to section 'Commands' of 'bcl2fastq' Commands

bcl2fastq

Link to section 'Module' of 'bcl2fastq' Module

You can load the modules by:

module load biocontainers
module load bcl2fastq

Link to section 'Example job' of 'bcl2fastq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bcl2fastq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bcl2fastq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bcl2fastq

beagle

Link to section 'Introduction' of 'beagle' Introduction

Beagle is a software package for phasing genotypes and for imputing ungenotyped markers. Start it with: beagle [java options] [arguments]
Note: Bref is not installed in this container.

For more information, please check its website: https://biocontainers.pro/tools/beagle and its home page: https://faculty.washington.edu/browning/beagle/beagle.html.

Link to section 'Versions' of 'beagle' Versions

5.1_24Aug19.3e8

Link to section 'Commands' of 'beagle' Commands

beagle

Link to section 'Module' of 'beagle' Module

You can load the modules by:

module load biocontainers
module load beagle

Link to section 'Example job' of 'beagle' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Beagle on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=beagle
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers beagle

beagle gt=test.vcf.gz out=test.out

beast2

Link to section 'Introduction' of 'beast2' Introduction

BEAST 2 is a cross-platform program for Bayesian phylogenetic analysis of molecular sequences.

For more information, please check its website: https://biocontainers.pro/tools/beast2 and its home page: https://www.beast2.org.

Link to section 'Versions' of 'beast2' Versions

2.6.3
2.6.4
2.6.6

Link to section 'Module' of 'beast2' Module

You can load the modules by:

module load biocontainers
module load beast2

Link to section 'Example job' of 'beast2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BEAST 2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=beast2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers beast2

beast -threads 4 -prefix input input.xml

bedops

Link to section 'Introduction' of 'bedops' Introduction

Bedops is a software package for manipulating and analyzing genomic interval data.

For more information, please check its website: https://biocontainers.pro/tools/bedops and its home page: https://bedops.readthedocs.io/en/latest/.

Link to section 'Versions' of 'bedops' Versions

2.4.39

Link to section 'Module' of 'bedops' Module

You can load the modules by:

module load biocontainers
module load bedops

Link to section 'Example job' of 'bedops' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bedops on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bedops
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bedops

bedops -m 001.merge.001.test > 001.merge.001.observed
bedops -c 001.merge.001.test > 001.complement.001.observed
bedops -i 001.intersection.001a.test 001.intersection.001b.test > 001.intersection.001.observed

bedtools

Link to section 'Introduction' of 'bedtools' Introduction

Bedtools is an extensive suite of utilities for genome arithmetic and comparing genomic features in BED format.

For more information, please check its website: https://biocontainers.pro/tools/bedtools and its home page on Github.

Link to section 'Versions' of 'bedtools' Versions

2.30.0

Link to section 'Module' of 'bedtools' Module

You can load the modules by:

module load biocontainers
module load bedtools

Link to section 'Example job' of 'bedtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bedtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bedtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bedtools

bedtools intersect -a a.bed -b b.bed
bedtools annotate -i variants.bed -files genes.bed conserve.bed known_var.bed

bioawk

Link to section 'Introduction' of 'bioawk' Introduction

Bioawk is an extension to Brian Kernighan's awk, adding the support of several common biological data formats, including optionally gzipped BED, GFF, SAM, VCF, FASTA/Q and TAB-delimited formats with column names.

For more information, please check its website: https://biocontainers.pro/tools/bioawk and its home page on Github.

Link to section 'Versions' of 'bioawk' Versions

Link to section 'Commands' of 'bioawk' Commands

bioawk

Link to section 'Module' of 'bioawk' Module

You can load the modules by:

module load biocontainers
module load bioawk

Link to section 'Example job' of 'bioawk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bioawk on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bioawk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bioawk

bioawk -c fastx '{print ">"$name;print revcomp($seq)}' seq.fa.gz

biobambam

Link to section 'Introduction' of 'biobambam' Introduction

Biobambam is a collection of tools for early stage alignment file processing.

For more information, please check its website: https://biocontainers.pro/tools/biobambam and its home page on Gitlab.

Link to section 'Versions' of 'biobambam' Versions

2.0.183

Link to section 'Module' of 'biobambam' Module

You can load the modules by:

module load biocontainers
module load biobambam

Link to section 'Example job' of 'biobambam' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Biobambam on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=biobambam
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers biobambam

bammarkduplicates I=Aligned.sortedByCoord.out.bam O=out.bam D=duplcate_out

bamsort I=Aligned.sortedByCoord.out.bam O=sorted.bam sortthreads=8

bamtofastq filename=Aligned.sortedByCoord.out.bam outputdir=fastq_out

bioconvert

Link to section 'Introduction' of 'bioconvert' Introduction

Bioconvert is a collaborative project to facilitate the interconversion of life science data from one format to another.

For more information, please check its website: https://biocontainers.pro/tools/bioconvert.

Link to section 'Versions' of 'bioconvert' Versions

0.4.3
0.5.2
0.6.1
0.6.2

Link to section 'Commands' of 'bioconvert' Commands

bioconvert

Link to section 'Module' of 'bioconvert' Module

You can load the modules by:

module load biocontainers
module load bioconvert

Link to section 'Example job' of 'bioconvert' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bioconvert on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bioconvert
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bioconvert

bioconvert fastq2fasta input.fastq output.fa

biopython

Link to section 'Introduction' of 'biopython' Introduction

Biopython is a set of freely available tools for biological computation written in Python.

For more information, please check its website: https://biocontainers.pro/tools/biopython and its home page: https://biopython.org.

Link to section 'Versions' of 'biopython' Versions

1.70-np112py27
1.70-np112py36
1.78

Link to section 'Module' of 'biopython' Module

You can load the modules by:

module load biocontainers
module load biopython

Link to section 'Interactive job' of 'biopython' Interactive job

To run biopython interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers biopython
(base) UserID@bell-a008:~ $ python
Python 3.9.1 |  packaged by conda-forge |  (default, Jan 26 2021, 01:34:10) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from Bio import SeqIO
>>> with open("input.gb") as input_handle:
    for record in SeqIO.parse(input_handle, "genbank"):
          print(record)

Link to section 'Batch job' of 'biopython' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Biopython on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=biopython
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers biopython

python script.py

bismark

Link to section 'Introduction' of 'bismark' Introduction

Bismark is a tool to map bisulfite treated sequencing reads to a genome of interest and perform methylation calls in a single step.

For more information, please check its website: https://biocontainers.pro/tools/bismark and its home page on Github.

Link to section 'Versions' of 'bismark' Versions

0.23.0

Link to section 'Dependencies' of 'bismark' Dependencies

Bowtie v2.4.2, Samtools v1.12, HISAT2 v2.2.1 were included in the container image. So users do not need to provide the dependency path in the bismark parameter.

Link to section 'Module' of 'bismark' Module

You can load the modules by:

module load biocontainers
module load bismark

Link to section 'Example job' of 'bismark' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bismark on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=bismark
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bismark

bismark_genome_preparation --bowtie2 data/ref_genome

bismark --multicore 12 --genome data/ref_genome seq.fastq

blasr

Link to section 'Introduction' of 'blasr' Introduction

Blasr Blasr is a read mapping program that maps reads to positions in a genome by clustering short exact matches between the read and the genome, and scoring clusters using alignment.

For more information, please check its website: https://biocontainers.pro/tools/blasr.

Link to section 'Versions' of 'blasr' Versions

5.3.5

Link to section 'Commands' of 'blasr' Commands

blasr

Link to section 'Module' of 'blasr' Module

You can load the modules by:

module load biocontainers
module load blasr

Link to section 'Example job' of 'blasr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Blasr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=blasr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers blasr

blasr reads.bas.h5  ecoli_K12.fasta -sam

blast

Link to section 'Introduction' of 'blast' Introduction

BLAST (Basic Local Alignment Search Tool) finds regions of similarity between biological sequences. The program compares nucleotide or protein sequences to sequence databases and calculates the statistical significance.

For more information, please check its website: https://biocontainers.pro/tools/blast and its home page: https://blast.ncbi.nlm.nih.gov/Blast.cgi?CMD=Web&PAGE_TYPE=BlastHome.

Link to section 'Versions' of 'blast' Versions

2.11.0
2.13.0

Link to section 'Module' of 'blast' Module

You can load the modules by:

module load biocontainers
module load blast

Link to section 'BLAST Databases' of 'blast' BLAST Databases

Local copies of the blast dabase can be found in the directory /depot/itap/datasets/blast/latest/. The environment varialbe BLASTDB was also set as /depot/itap/datasets/blast/latest/. If users want to use cdd_delta, env_nr, env_nt, nr, nt, pataa, patnt, pdbnt, refseq_protein, refseq_rna, swissprot, or tsa_nt databases, do not need to provide the database path. Instead, just use the format like this -db nr.

Link to section 'Example job' of 'blast' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BLAST on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=blast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers blast

blastp -query protein.fasta -db nr -out test_out -num_threads 4

blobtools

BlobTools is a modular command-line solution for visualisation, quality control and taxonomic partitioning of genome datasets.

Detailed usage can be found here: https://github.com/DRL/blobtools

Link to section 'Versions' of 'blobtools' Versions

1.1.1

Link to section 'Commands' of 'blobtools' Commands

blobtools

Link to section 'Module' of 'blobtools' Module

You can load the modules by:

module load biocontainers
module load blobtools/1.1.1

Link to section 'Example job' of 'blobtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run blobtools on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=blobtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers blobtools/1.1.1

blobtools create -i example/assembly.fna -b example/mapping_1.sorted.bam -t example/blast.out -o test && \
blobtools view -i test.blobDB.json && \
blobtools plot -i test.blobDB.json

bmge

Link to section 'Introduction' of 'bmge' Introduction

Bmge is a program that selects regions in a multiple sequence alignment that are suited for phylogenetic inference.

For more information, please check its website: https://biocontainers.pro/tools/bmge and its home page: https://bioweb.pasteur.fr/packages/pack@BMGE@1.12.

Link to section 'Versions' of 'bmge' Versions

1.12

Link to section 'Commands' of 'bmge' Commands

bmge

Link to section 'Module' of 'bmge' Module

You can load the modules by:

module load biocontainers
module load bmge

Link to section 'Example job' of 'bmge' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bmge on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bmge
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bmge

bmge -i seq.fa -t AA -o out.phy

bowtie

Link to section 'Introduction' of 'bowtie' Introduction

Bowtie is an ultrafast, memory-efficient short read aligner. It aligns short DNA sequences (reads) to the human genome at a rate of over 25 million 35-bp reads per hour. Bowtie indexes the genome with a Burrows-Wheeler index to keep its memory footprint small: typically about 2.2 GB for the human genome (2.9 GB for paired-end).

For more information, please check its website: https://biocontainers.pro/tools/bowtie and its home page: http://bowtie-bio.sourceforge.net/.

Link to section 'Versions' of 'bowtie' Versions

1.3.1

Link to section 'Commands' of 'bowtie' Commands

bowtie
bowtie-build
bowtie-inspect

Link to section 'Module' of 'bowtie' Module

You can load the modules by:

module load biocontainers
module load bowtie

Link to section 'Example job' of 'bowtie' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bowtie on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bowtie
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bowtie

bowtie-build ref.fasta ref
bowtie -p 4 -x ref -1 input_1.fq -2 input_2.fq -S test.sam

bowtie2

Link to section 'Introduction' of 'bowtie2' Introduction

Bowtie 2is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. It is particularly good at aligning reads of about 50 up to 100s or 1,000s of characters, and particularly good at aligning to relatively long (e.g. mammalian) genomes. Bowtie 2 indexes the genome with an FM Index to keep its memory footprint small: for the human genome, its memory footprint is typically around 3.2 GB. Bowtie 2 supports gapped, local, and paired-end alignment modes.

For more information, please check its website: https://biocontainers.pro/tools/bowtie2 and its home page on Github.

Link to section 'Versions' of 'bowtie2' Versions

2.4.2
2.5.1

Link to section 'Commands' of 'bowtie2' Commands

bowtie2
bowtie2-build
bowtie2-inspect

Link to section 'Module' of 'bowtie2' Module

You can load the modules by:

module load biocontainers
module load bowtie2

Link to section 'Example job' of 'bowtie2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bowtie 2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bowtie2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bowtie2

bowtie2-build ref.fasta ref
bowtie2 -p 4 -x ref -1 input_1.fq -2 input_2.fq -S test.sam

bracken

Bracken (Bayesian Reestimation of Abundance with KrakEN) is a highly accurate statistical method that computes the abundance of species in DNA sequences from a metagenomics sample.

Detailed usage can be found here: https://github.com/jenniferlu717/Bracken

Inside the bracken container image, kraken2 was also installed. As a result, when you load bracken/2.6.1-py37, kraken version 2.1.1 will be automatically loaded. Please do not load kraken2 module together with bracken module to avoid conflict.

Link to section 'Versions' of 'bracken' Versions

2.6.1
2.7

Link to section 'Module' of 'bracken' Module

You can load the modules by:

module load biocontainers
module load bracken/2.6.1-py37

Link to section 'Example job' of 'bracken' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bracken on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=bracken
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bracken/2.6.1-py37

DATABASE=minikraken2_v2_8GB_201904_UPDATE
kraken2 --threads 24  --report kranken2.report --db $DATABASE --paired --classified-out cseqs#.fq SRR5043021_1.fastq SRR5043021_2.fastq
bracken -d  $DATABASE -i kranken2.report -o bracken_output -w bracken.report

braker2

Link to section 'Introduction' of 'braker2' Introduction

BRAKER is a pipeline for fully automated prediction of protein coding gene structures with GeneMark-ES/ET and AUGUSTUS in novel eukaryotic genomes.

For more information. please check its github repository https://github.com/Gaius-Augustus/BRAKER.

Link to section 'Versions' of 'braker2' Versions

2.1.6

Commands
braker.pl

Helper command

Since BRAKER is a pipeline that trains AUGUSTUS, i.e. writes species specific parameter files, BRAKER needs writing access to the configuration directory of AUGUSTUS that contains such files. This installation comes with a stub of AUGUSTUS configuration files, but you must copy them out from the container into a location where you have write permissions.

A helper command copy_augustus_config is provided to simplify the task. Follow the procedure below to put the config files in your scratch space:

$ mkdir -p $RCAC_SCRATCH/augustus
$ copy_augustus_config $RCAC_SCRATCH/augustus
$ export AUGUSTUS_CONFIG_PATH=$RCAC_SCRATCH/augustus/config

Link to section 'Module' of 'braker2' Module

You can load the modules by:

module load biocontainers
module load braker2/2.1.6

Link to section 'Example job' of 'braker2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BRAKER on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=BRAKER2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers braker2/2.1.6 

# The augustus config step is only required for the first time to use BRAKER2
mkdir -p $RCAC_SCRATCH/augustus
copy_augustus_config $RCAC_SCRATCH/augustus
export AUGUSTUS_CONFIG_PATH=$RCAC_SCRATCH/augustus/config
  
braker.pl --genome genome.fa --bam RNAseq.bam --softmasking --cores 24

brass

Link to section 'Introduction' of 'brass' Introduction

Brass is used to analyze one or more related BAM files of paired-end sequencing to determine potential rearrangement breakpoints.

For more information, please check its website: https://quay.io/repository/wtsicgp/brass and its home page on Github.

Link to section 'Versions' of 'brass' Versions

6.3.4

Link to section 'Module' of 'brass' Module

You can load the modules by:

module load biocontainers
module load brass

Link to section 'Example job' of 'brass' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Brass on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=brass
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers brass

brass.pl -c 4 -o myout -t tumour.bam -n normal.bam

breseq

Link to section 'Introduction' of 'breseq' Introduction

Breseq is a computational pipeline for the analysis of short-read re-sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/breseq and its home page on Github.

Link to section 'Versions' of 'breseq' Versions

0.36.1

Link to section 'Commands' of 'breseq' Commands

breseq

Link to section 'Module' of 'breseq' Module

You can load the modules by:

module load biocontainers
module load breseq

Link to section 'Example job' of 'breseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Breseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=breseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers breseq

busco

Link to section 'Introduction' of 'busco' Introduction

BUSCO (Benchmarking sets of Universal Single-Copy Orthologs) provides measures for quantitative assessment of genome assembly, gene set, and transcriptome completeness based on evolutionarily informed expectations of gene content from near-universal single-copy orthologs.

Detailed information can be found here: https://gitlab.com/ezlab/busco/

Link to section 'Versions' of 'busco' Versions

5.2.2
5.3.0
5.4.1
5.4.3
5.4.4
5.4.5
5.4.7

Commands
- busco - generate_plot.py

Helper command

Augustus is a gene prediction program for eukaryotes which is required by BUSCO. Augustus requires a writable configuration directory. This installation comes with a stub of AUGUSTUS configuration files, but you must copy them out from the container into a location where you have write permissions.

A helper command copy_augustus_config is provided to simplify the task. Follow the procedure below to put the config files in your scratch space:

$ mkdir -p $RCAC_SCRATCH/augustus
$ copy_augustus_config $RCAC_SCRATCH/augustus
$ export AUGUSTUS_CONFIG_PATH=$RCAC_SCRATCH/augustus/config

Link to section 'Module' of 'busco' Module

You can load the modules by:

module load biocontainers
module load busco

Link to section 'Example job for prokaryotic genomes' of 'busco' Example job for prokaryotic genomes

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BUSCO on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=BUSCO
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers busco

## Print the full lineage datasets, and find the dataset fitting your organism. 
busco --list-datasets

## run the evaluation
busco -f -c 12 -l actinobacteria_class_odb10  -i bacteria_genome.fasta -o busco_out -m genome

## generate a simple summary plot
generate_plot.py -wd busco_out

Link to section 'Example job for eukaryotic genomes' of 'busco' Example job for eukaryotic genomes

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BUSCO on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=BUSCO
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers busco

## The augustus config step is only required for the first time to use BUSCO
mkdir -p $RCAC_SCRATCH/augustus
copy_augustus_config $RCAC_SCRATCH/augustus

## This is required for eukaryotic genomes 
export AUGUSTUS_CONFIG_PATH=$RCAC_SCRATCH/augustus/config
  
## Print the full lineage datasets, and find the dataset fitting your organism. 
busco --list-datasets

## run the evaluation
busco -f -c 12 -l fungi_odb10 -i fungi_protein.fasta -o busco_out_protein  -m protein
busco -f -c 12 --augustus -l fungi_odb10 -i fungi_genome.fasta -o busco_out_genome  -m genome

## generate a simple summary plot
generate_plot.py -wd busco_out_protein
generate_plot.py -wd busco_out_genome

bustools

Link to section 'Introduction' of 'bustools' Introduction

Bustools is a program for manipulating BUS files for single cell RNA-Seq datasets.

For more information, please check its website: https://biocontainers.pro/tools/bustools and its home page on Github.

Link to section 'Versions' of 'bustools' Versions

0.41.0

Link to section 'Commands' of 'bustools' Commands

bustools

Link to section 'Module' of 'bustools' Module

You can load the modules by:

module load biocontainers
module load bustools

Link to section 'Example job' of 'bustools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Bustools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bustools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bustools

bustools capture -s -o cDNA_capture.bus -c cDNA_transcripts.to_capture.txt -e matrix.ec -t transcripts.txt output.correct.sort.bus
bustools count -o u -g cDNA_introns_t2g.txt -e matrix.ec -t transcripts.txt --genecounts cDNA_capture.bus

bwa

Link to section 'Introduction' of 'bwa' Introduction

BWA (Burrows-Wheeler Aligner) is a fast, accurate, memory-efficient aligner for short and long sequencing reads.

For more information, please check its website: https://biocontainers.pro/tools/bwa and its home page: http://bio-bwa.sourceforge.net.

Link to section 'Versions' of 'bwa' Versions

0.7.17

Link to section 'Commands' of 'bwa' Commands

bwa
qualfa2fq.pl
xa2multi.pl

Link to section 'Module' of 'bwa' Module

You can load the modules by:

module load biocontainers
module load bwa

Link to section 'Example job' of 'bwa' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BWA on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bwa
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bwa

bwa index ref.fasta
bwa mem ref.fasta input.fq > test.sam

bwameth

Link to section 'Introduction' of 'bwameth' Introduction

Bwameth is a tool for fast and accurante alignment of BS-Seq reads.

BioContainers: https://biocontainers.pro/tools/bwameth
Home page: https://github.com/brentp/bwa-meth

Link to section 'Versions' of 'bwameth' Versions

0.2.5

Link to section 'Commands' of 'bwameth' Commands

bwameth.py

Link to section 'Module' of 'bwameth' Module

You can load the modules by:

module load biocontainers
module load bwameth

Link to section 'Example job' of 'bwameth' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bwameth on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bwameth
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bwameth

cactus

Link to section 'Introduction' of 'cactus' Introduction

Cactus is a reference-free whole-genome multiple alignment program.

For more information, please check its website: https://biocontainers.pro/tools/cactus and its home page on Github.

Link to section 'Module' of 'cactus' Module

You can load the modules by:

module load biocontainers
module load cactus

Link to section 'Example job' of 'cactus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cactus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cactus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cactus

wget https://raw.githubusercontent.com/ComparativeGenomicsToolkit/cactus/master/examples/evolverMammals.txt
cactus jobStore evolverMammals.txt evolverMammals.hal

cafe

Link to section 'Introduction' of 'cafe' Introduction

Cafe is a computational tool for the study of gene family evolution.

For more information, please check its website: https://biocontainers.pro/tools/cafe and its home page on Github.

Link to section 'Versions' of 'cafe' Versions

4.2.1
5.0.0

Link to section 'Commands' of 'cafe' Commands

cafe

Link to section 'Module' of 'cafe' Module

You can load the modules by:

module load biocontainers
module load cafe

Link to section 'Example job' of 'cafe' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cafe on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cafe
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cafe

#To get a list of commands just call CAFE with the -h or --help arguments
cafe5 -h

#To estimate lambda with no among family rate variation issue the command
cafe5 -i mammal_gene_families.txt -t mammal_tree.txt

canu

Canu is a single molecule sequence assembler for genomes large and small.

Detailed usage can be found here: https://github.com/marbl/canu

Link to section 'Versions' of 'canu' Versions

2.1.1
2.2

Link to section 'Commands' of 'canu' Commands

canu

Link to section 'Module' of 'canu' Module

You can load the modules by:

module load biocontainers
module load canu/2.2

Link to section 'Example job' of 'canu' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run canu on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=canu
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers canu/2.2

canu -p Cm -d clavibacter_pacbio genomeSize=3.4m  -pacbio *.fastq

ccs

Link to section 'Introduction' of 'ccs' Introduction

Pbccs is a tool to generate Highly Accurate Single-Molecule Consensus Reads (HiFi Reads).

BioContainers: https://biocontainers.pro/tools/pbccs
Home page: https://github.com/PacificBiosciences/ccs

Link to section 'Versions' of 'ccs' Versions

6.4.0

Link to section 'Commands' of 'ccs' Commands

Link to section 'Module' of 'ccs' Module

You can load the modules by:

module load biocontainers
module load ccs

Link to section 'Example job' of 'ccs' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ccs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ccs
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ccs

ccs --all subreads.bam ccs.bam

cd-hit

Link to section 'Introduction' of 'cd-hit' Introduction

Cd-hit is a very widely used program for clustering and comparing protein or nucleotide sequences.

For more information, please check its website: https://biocontainers.pro/tools/cd-hit and its home page on Github.

Link to section 'Versions' of 'cd-hit' Versions

4.8.1

Link to section 'Module' of 'cd-hit' Module

You can load the modules by:

module load biocontainers
module load cd-hit

Link to section 'Example job' of 'cd-hit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cd-hit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cd-hit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cd-hit

cd-hit -i Cm_pep.fasta  -o Cmdb90 -c 0.9 -n 5 -M 16000 -T 8

cd-hit-est -i Cm_dna.fasta  -o Cmdb90_nt -c 0.9 -n 5 -M 16000 -T 8

cdbtools

Link to section 'Introduction' of 'cdbtools' Introduction

Cdbtools is a collection of tools used for creating indices for quick retrieval of any particular sequences from large multi-FASTA files.

For more information, please check its website: https://biocontainers.pro/tools/cdbtools.

Link to section 'Versions' of 'cdbtools' Versions

0.99

Link to section 'Commands' of 'cdbtools' Commands

cdbfasta
cdbyank

Link to section 'Module' of 'cdbtools' Module

You can load the modules by:

module load biocontainers
module load cdbtools

Link to section 'Example job' of 'cdbtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cdbtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cdbtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cdbtools

cdbfasta genome.fa
cdbyank -a 'seq_1' genome.fa.cidx

cegma

Link to section 'Introduction' of 'cegma' Introduction

CEGMA (Core Eukaryotic Genes Mapping Approach) is a pipeline for building a set of high reliable set of gene annotations in virtually any eukaryotic genome.

Docker hub: https://hub.docker.com/r/chrishah/cegma
Home page: https://github.com/KorfLab/CEGMA_v2

Link to section 'Versions' of 'cegma' Versions

Link to section 'Commands' of 'cegma' Commands

cegma

Link to section 'Module' of 'cegma' Module

You can load the modules by:

module load biocontainers
module load cegma

Link to section 'Example job' of 'cegma' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cegma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cegma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cegma

cegma --genome genome.fasta -o output

cellbender

Link to section 'Introduction' of 'cellbender' Introduction

Cellbender is a software package for eliminating technical artifacts from high-throughput single-cell RNA sequencing (scRNA-seq) data.

For more information, please check its website: https://biocontainers.pro/tools/cellbender and its home page on Github.

Link to section 'Versions' of 'cellbender' Versions

0.2.0
0.2.2

Link to section 'Commands' of 'cellbender' Commands

cellbender

Link to section 'Module' of 'cellbender' Module

You can load the modules by:

module load biocontainers
module load cellbender

Link to section 'Example job' of 'cellbender' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cellbender on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=cellbender
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellbender

cellbender remove-background \
             --input cellranger/test_count/run_count_1kpbmcs/outs/raw_feature_bc_matrix.h5 \
             --output output_cpu.h5 \
             --expected-cells 1000 \
             --total-droplets-included 20000 \
             --fpr 0.01 \
             --epochs 150

cellphonedb

Link to section 'Introduction' of 'cellphonedb' Introduction

CellPhoneDB is a publicly available repository of curated receptors, ligands and their interactions.

Docker hub: https://hub.docker.com/r/eagleshot/cellphonedb
Home page: https://github.com/Teichlab/cellphonedb

Link to section 'Versions' of 'cellphonedb' Versions

2.1.7

Link to section 'Commands' of 'cellphonedb' Commands

cellphonedb

Link to section 'Module' of 'cellphonedb' Module

You can load the modules by:

module load biocontainers
module load cellphonedb

Link to section 'Example job' of 'cellphonedb' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cellphonedb on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cellphonedb
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellphonedb

cellranger

Cellranger is a set of analysis pipelines that process Chromium single-cell data to align reads, generate feature-barcode matrices, perform clustering and other secondary analysis, and more.
Detailed usage can be found here: https://support.10xgenomics.com/single-cell-gene-expression/software/pipelines/latest/what-is-cell-ranger.

Link to section 'Versions' of 'cellranger' Versions

6.0.1
6.1.1
6.1.2
7.0.0
7.0.1
7.1.0

Link to section 'Commands' of 'cellranger' Commands

cellranger mkfastq
cellranger count
cellranger aggr
cellranger reanalyze
cellranger multi

Link to section 'Module' of 'cellranger' Module

You can load the modules by:

module load biocontainers
module load cellranger

Link to section 'Example job' of 'cellranger' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cellranger our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 48
#SBATCH --job-name=cellranger
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellranger

cellranger count --id=run_count_1kpbmcs --fastqs=pbmc_1k_v3_fastqs --sample=pbmc_1k_v3 --transcriptome=refdata-gex-GRCh38-2020-A

cellranger-arc

Link to section 'Introduction' of 'cellranger-arc' Introduction

Cell Ranger ARC is a set of analysis pipelines that process Chromium Single Cell Multiome ATAC + Gene Expression sequencing data to generate a variety of analyses pertaining to gene expression (GEX), chromatin accessibility, and their linkage. Furthermore, since the ATAC and GEX measurements are on the very same cell, we are able to perform analyses that link chromatin accessibility and GEX.

Docker hub: https://hub.docker.com/r/cumulusprod/cellranger-arc
Home page: https://support.10xgenomics.com/single-cell-multiome-atac-gex/software/pipelines/latest/what-is-cell-ranger-arc

Link to section 'Versions' of 'cellranger-arc' Versions

2.0.2_patched
2.0.2

Link to section 'Commands' of 'cellranger-arc' Commands

cellranger-arc

Link to section 'Module' of 'cellranger-arc' Module

You can load the modules by:

module load biocontainers
module load cellranger-arc

Link to section 'Example job' of 'cellranger-arc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cellranger-arc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cellranger-arc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellranger-arc

cellranger-atac

Link to section 'Introduction' of 'cellranger-atac' Introduction

Cellranger-atac is a set of analysis pipelines that process Chromium Single Cell ATAC data.

Docker hub: https://hub.docker.com/r/cumulusprod/cellranger-atac and its home page: https://support.10xgenomics.com/single-cell-atac/software/pipelines/latest/algorithms/overview.

Link to section 'Versions' of 'cellranger-atac' Versions

2.0.0
2.1.0

Link to section 'Commands' of 'cellranger-atac' Commands

cellranger-atac

Link to section 'Module' of 'cellranger-atac' Module

You can load the modules by:

module load biocontainers
module load cellranger-atac

Link to section 'Example job' of 'cellranger-atac' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cellranger-atac on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --mem=64G
#SBATCH --job-name=cellranger-atac
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellranger-atac

cellranger-atac count --id=sample345 \
                    --reference=refdata-cellranger-arc-GRCh38-2020-A-2.0.0 \
                    --fastqs=runs/HAWT7ADXX/outs/fastq_path \
                    --sample=mysample \
                    --localcores=8 \
                    --localmem=64

cellranger-dna

Link to section 'Introduction' of 'cellranger-dna' Introduction

Cell Ranger DNA is a set of analysis pipelines that process Chromium single cell DNA sequencing output to align reads, identify copy number variation (CNV), and compare heterogeneity among cells.

Home page: https://support.10xgenomics.com/single-cell-dna/software/pipelines/latest/what-is-cell-ranger-dna

Link to section 'Versions' of 'cellranger-dna' Versions

1.1.0

Link to section 'Commands' of 'cellranger-dna' Commands

cellranger-dna

Link to section 'Module' of 'cellranger-dna' Module

You can load the modules by:

module load biocontainers
module load cellranger-dna

Link to section 'Example job' of 'cellranger-dna' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cellranger-dna on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cellranger-dna
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellranger-dna

cellrank

CellRank a toolkit to uncover cellular dynamics based on Markov state modeling of single-cell data. Detailed information about CellRank can be found here: https://cellrank.readthedocs.io/en/stable/.

Link to section 'Versions' of 'cellrank' Versions

1.5.1

Link to section 'Commands' of 'cellrank' Commands

python
python3

Link to section 'Module' of 'cellrank' Module

You can load the modules by:

module load biocontainers  
module load cellrank/1.5.1

The CellRank container also contained scVelo and scanpy. When you want to use CellRank, do not load scVelo or scanpy.

Link to section 'Interactive job' of 'cellrank' Interactive job

To run CellRank interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers cellrank/1.5.1
(base) UserID@bell-a008:~ $ python
Python 3.9.9 |  packaged by conda-forge |  (main, Dec 20 2021, 02:41:03)
[GCC 9.4.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import scanpy as sc
>>> import scvelo as scv
>>> import cellrank as cr
>>> import numpy as np
>>> scv.settings.verbosity = 3
>>> scv.settings.set_figure_params("scvelo")
>>> cr.settings.verbosity = 2

Link to section 'Batch job' of 'cellrank' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=cellrank
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellrank/1.5.1

python script.py

cellrank-krylov

CellRank a toolkit to uncover cellular dynamics based on Markov state modeling of single-cell data. CellRank-krylov is CellRank installed with extra libraries, enabling it to have better performance for large datasets (>15k cells).

Detailed information about CellRank can be found here: https://cellrank.readthedocs.io/en/stable/.

Link to section 'Versions' of 'cellrank-krylov' Versions

1.5.1

Link to section 'Commands' of 'cellrank-krylov' Commands

python
python3

Link to section 'Module' of 'cellrank-krylov' Module

You can load the modules by:

module load biocontainers  
module load cellrank-krylov/1.5.1

The CellRank container also contained scVelo and scanpy. When you want to use CellRank, do not load scVelo or scanpy.

Link to section 'Interactive job' of 'cellrank-krylov' Interactive job

To run CellRank-krylov interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers cellrank-krylov/1.5.1
(base) UserID@bell-a008:~ $ python
Python 3.9.9 |  packaged by conda-forge |  (main, Dec 20 2021, 02:41:03)
[GCC 9.4.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import scanpy as sc
>>> import scvelo as scv
>>> import cellrank as cr
>>> import numpy as np
>>> scv.settings.verbosity = 3
>>> scv.settings.set_figure_params("scvelo")
>>> cr.settings.verbosity = 2

Link to section 'Batch job' of 'cellrank-krylov' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=cellrank-krylov
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellrank-krylov/1.5.1

python script.py

cellsnp-lite

Link to section 'Introduction' of 'cellsnp-lite' Introduction

cellSNP aims to pileup the expressed alleles in single-cell or bulk RNA-seq data, which can be directly used for donor deconvolution in multiplexed single-cell RNA-seq data, particularly with vireo, which assigns cells to donors and detects doublets, even without genotyping reference.

For more information, please check its website: https://biocontainers.pro/tools/cellsnp-lite and its home page on Github.

Link to section 'Versions' of 'cellsnp-lite' Versions

1.2.2

Link to section 'Commands' of 'cellsnp-lite' Commands

cellsnp-lite

Link to section 'Module' of 'cellsnp-lite' Module

You can load the modules by:

module load biocontainers
module load cellsnp-lite

Link to section 'Example job' of 'cellsnp-lite' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cellSNP on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=cellsnp-lite
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cellsnp-lite

cellsnp-lite -s sample.bam -b barcode.tsv -O cellsnp_out -p 8 --minMAF 0.1 --minCOUNT 100

celltypist

Link to section 'Introduction' of 'celltypist' Introduction

Celltypist is a tool for semi-automatic cell type annotation.

For more information, please check its website: https://biocontainers.pro/tools/celltypist and its home page on Github.

Link to section 'Versions' of 'celltypist' Versions

0.2.0
1.1.0

Link to section 'Commands' of 'celltypist' Commands

celltypist
python
python3

Link to section 'Module' of 'celltypist' Module

You can load the modules by:

module load biocontainers
module load celltypist

Link to section 'Example job' of 'celltypist' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Celltypist on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=celltypist
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers celltypist

celltypist --indata demo_2000_cells.h5ad --model Immune_All_Low.pkl --outdir output

centrifuge

Link to section 'Introduction' of 'centrifuge' Introduction

Centrifuge is a novel microbial classification engine that enables rapid, accurate, and sensitive labeling of reads and quantification of species on desktop computers.

For more information, please check its website: https://biocontainers.pro/tools/centrifuge and its home page: http://www.ccb.jhu.edu/software/centrifuge/.

Link to section 'Versions' of 'centrifuge' Versions

1.0.4_beta

Link to section 'Module' of 'centrifuge' Module

You can load the modules by:

module load biocontainers
module load centrifuge

Link to section 'Example job' of 'centrifuge' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Centrifuge on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=centrifuge
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers centrifuge

centrifuge-download -o taxonomy taxonomy
centrifuge-download -o library -m -d "archaea,bacteria,viral" refseq > seqid2taxid.map
cat library/*/*.fna > input-sequences.fna
centrifuge-build -p 8 --conversion-table seqid2taxid.map \
             --taxonomy-tree taxonomy/nodes.dmp --name-table taxonomy/names.dmp \
             input-sequences.fna abv

cfsan-snp-pipeline

Link to section 'Introduction' of 'cfsan-snp-pipeline' Introduction

The CFSAN SNP Pipeline is a Python-based system for the production of SNP matrices from sequence data used in the phylogenetic analysis of pathogenic organisms sequenced from samples of interest to food safety.

Docker hub: https://hub.docker.com/r/staphb/cfsan-snp-pipeline
Home page: https://github.com/CFSAN-Biostatistics/snp-pipeline

Link to section 'Versions' of 'cfsan-snp-pipeline' Versions

2.2.1

Link to section 'Commands' of 'cfsan-snp-pipeline' Commands

cfsan_snp_pipeline

Link to section 'Module' of 'cfsan-snp-pipeline' Module

You can load the modules by:

module load biocontainers
module load cfsan-snp-pipeline

Link to section 'Example job' of 'cfsan-snp-pipeline' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cfsan-snp-pipeline on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cfsan-snp-pipeline
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cfsan-snp-pipeline

checkm-genome

Link to section 'Introduction' of 'checkm-genome' Introduction

CheckM provides a set of tools for assessing the quality of genomes recovered from isolates, single cells, or metagenomes.

BioContainers: https://biocontainers.pro/tools/checkm-genome
Home page: https://github.com/Ecogenomics/CheckM

Link to section 'Versions' of 'checkm-genome' Versions

1.2.0
1.2.2

Link to section 'Commands' of 'checkm-genome' Commands

checkm-genome

Link to section 'Module' of 'checkm-genome' Module

You can load the modules by:

module load biocontainers
module load checkm-genome

Link to section 'Example job' of 'checkm-genome' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run checkm-genome on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=checkm-genome
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers checkm-genome

checkm lineage_wf -t 8 -x fa bins checkm

chewbbaca

Link to section 'Introduction' of 'chewbbaca' Introduction

chewBBACA is a comprehensive pipeline including a set of functions for the creation and validation of whole genome and core genome MultiLocus Sequence Typing (wg/cgMLST) schemas, providing an allele calling algorithm based on Blast Score Ratio that can be run in multiprocessor settings and a set of functions to visualize and validate allele variation in the loci. chewBBACA performs the schema creation and allele calls on complete or draft genomes resulting from de novo assemblers.

BioContainers: https://biocontainers.pro/tools/chewbbaca
Home page: https://github.com/B-UMMI/chewBBACA

Link to section 'Versions' of 'chewbbaca' Versions

2.8.5

Link to section 'Commands' of 'chewbbaca' Commands

chewBBACA.py

Link to section 'Module' of 'chewbbaca' Module

You can load the modules by:

module load biocontainers
module load chewbbaca

Link to section 'Example job' of 'chewbbaca' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run chewbbaca on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=chewbbaca
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers chewbbaca

chewBBACA.py CreateSchema -i complete_genomes/ -o tutorial_schema --ptf Streptococcus_agalactiae.trn --cpu 4
chewBBACA.py AlleleCall -i complete_genomes/ -g tutorial_schema/schema_seed -o results32_wgMLST --cpu 4

chopper

Link to section 'Introduction' of 'chopper' Introduction

Chopper is Rust implementation of NanoFilt+NanoLyse, both originally written in Python. This tool, intended for long read sequencing such as PacBio or ONT, filters and trims a fastq file. Filtering is done on average read quality and minimal or maximal read length, and applying a headcrop (start of read) and tailcrop (end of read) while printing the reads passing the filter.

BioContainers: https://biocontainers.pro/tools/chopper
Home page: https://github.com/wdecoster/chopper

Link to section 'Versions' of 'chopper' Versions

0.2.0

Link to section 'Commands' of 'chopper' Commands

chopper

Link to section 'Module' of 'chopper' Module

You can load the modules by:

module load biocontainers
module load chopper

Link to section 'Example job' of 'chopper' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run chopper on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=chopper
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers chopper

chromap

Link to section 'Introduction' of 'chromap' Introduction

Chromap is an ultrafast method for aligning and preprocessing high throughput chromatin profiles.

BioContainers: https://biocontainers.pro/tools/chromap
Home page: https://github.com/haowenz/chromap

Link to section 'Versions' of 'chromap' Versions

0.2.2

Link to section 'Commands' of 'chromap' Commands

chromap

Link to section 'Module' of 'chromap' Module

You can load the modules by:

module load biocontainers
module load chromap

Link to section 'Example job' of 'chromap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run chromap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=chromap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers chromap

cicero

Link to section 'Introduction' of 'cicero' Introduction

CICERO (Clipped-reads Extended for RNA Optimization) is an assembly-based algorithm to detect diverse classes of driver gene fusions from RNA-seq.

For more information, please check its home page on Github.

Link to section 'Versions' of 'cicero' Versions

1.8.1

Link to section 'Commands' of 'cicero' Commands

Cicero.sh

Link to section 'Module' of 'cicero' Module

You can load the modules by:

module load biocontainers
module load cicero

Link to section 'Example job' of 'cicero' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run CICERO on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cicero
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cicero

circexplorer2

Link to section 'Introduction' of 'circexplorer2' Introduction

CIRCexplorer2 is a comprehensive and integrative circular RNA analysis toolset. It is the successor of CIRCexplorer with plenty of new features to facilitate circular RNA identification and characterization.

BioContainers: https://biocontainers.pro/tools/circexplorer2
Home page: https://github.com/YangLab/CIRCexplorer2

Link to section 'Versions' of 'circexplorer2' Versions

2.3.8

Link to section 'Commands' of 'circexplorer2' Commands

CIRCexplorer2
fast_circ.py
fetch_ucsc.py

Link to section 'Module' of 'circexplorer2' Module

You can load the modules by:

module load biocontainers
module load circexplorer2

Link to section 'Example job' of 'circexplorer2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run circexplorer2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=circexplorer2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers circexplorer2

circlator

Link to section 'Introduction' of 'circlator' Introduction

Circlator is a tool to circularize genome assemblies.

Docker hub: https://hub.docker.com/r/sangerpathogens/circlator and its home page on Github.

Link to section 'Versions' of 'circlator' Versions

1.5.5

Link to section 'Commands' of 'circlator' Commands

circlator
python3

Link to section 'Module' of 'circlator' Module

You can load the modules by:

module load biocontainers
module load circlator

Link to section 'Example job' of 'circlator' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Circlator on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=circlator
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers circlator

circlator minimus2  minimus2_test_run_minimus2.in.fa  minimus2_test

circompara2

Link to section 'Introduction' of 'circompara2' Introduction

CirComPara2 is a computational pipeline to detect, quantify, and correlate expression of linear and circular RNAs from RNA-seq data that combines multiple circRNA-detection methods.

Home page: https://github.com/egaffo/circompara2

Link to section 'Versions' of 'circompara2' Versions

0.1.2.1

Link to section 'Module' of 'circompara2' Module

You can load the modules by:

module load biocontainers
module load circompara2

Link to section 'Example job' of 'circompara2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run circompara2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=circompara2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers circompara2

circos

Link to section 'Introduction' of 'circos' Introduction

Circos is a software package for visualizing data and information.

For more information, please check its website: https://biocontainers.pro/tools/circos and its home page: http://circos.ca.

Link to section 'Versions' of 'circos' Versions

0.69.8

Link to section 'Commands' of 'circos' Commands

circos

Link to section 'Module' of 'circos' Module

You can load the modules by:

module load biocontainers
module load circos

Link to section 'Example job' of 'circos' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Circos on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=circos
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers circos

circos -conf circos.conf

ciri2

Link to section 'Introduction' of 'ciri2' Introduction

CIRI2: Circular RNA identification based on multiple seed matching

Home page: https://sourceforge.net/projects/ciri/files/CIRI2/

Link to section 'Versions' of 'ciri2' Versions

2.0.6

Link to section 'Commands' of 'ciri2' Commands

CIRI2.pl

Link to section 'Module' of 'ciri2' Module

You can load the modules by:

module load biocontainers
module load ciri2

Link to section 'Example job' of 'ciri2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ciri2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ciri2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ciri2

ciriquant

Link to section 'Introduction' of 'ciriquant' Introduction

CIRIquant is a comprehensive analysis pipeline for circRNA detection and quantification in RNA-Seq data.

Docker hub: https://hub.docker.com/r/mortreux/ciriquant and its home page on Github.

Link to section 'Versions' of 'ciriquant' Versions

1.1.2

Link to section 'Commands' of 'ciriquant' Commands

CIRIquant

Link to section 'Module' of 'ciriquant' Module

You can load the modules by:

module load biocontainers
module load ciriquant

Link to section 'config.yml ' of 'ciriquant' config.yml

All required dependencies have been installed within the CIRIquant container image. But users still need toprovide the PATH of these executables in `config.yml`. Please use the below `config.yml` as example:

name: hg38
tools:
   bwa: /bin/bwa
   hisat2: /bin/hisat2
   stringtie: /bin/stringtie
   samtools: /usr/local/bin/samtools
reference:
   fasta: reference/Homo_sapiens.GRCh38.dna.primary_assembly.fa
   gtf:  reference/Homo_sapiens.GRCh38.105.gtf
   bwa_index: reference/Homo_sapiens.GRCh38.dna.primary_assembly.fa
   hisat_index: reference/hg38_hisat2

Link to section 'Example job' of 'ciriquant' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run CIRIquant on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 64
#SBATCH --job-name=ciriquant
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ciriquant

CIRIquant -t 64 -1 SRR12095148_1.fastq -2 SRR12095148_2.fastq --config config.yml -o Output -p test

clair3

Link to section 'Introduction' of 'clair3' Introduction

Clair3 is a germline small variant caller for long-reads. Clair3 makes the best of two major method categories: pileup calling handles most variant candidates with speed, and full-alignment tackles complicated candidates to maximize precision and recall. Clair3 runs fast and has superior performance, especially at lower coverage. Clair3 is simple and modular for easy deployment and integration.

Docker hub: https://hub.docker.com/r/hkubal/clair3
Home page: https://github.com/HKU-BAL/Clair3

Link to section 'Versions' of 'clair3' Versions

0.1-r11
0.1-r12

Link to section 'Commands' of 'clair3' Commands

run_clair3.sh

Link to section 'Module' of 'clair3' Module

You can load the modules by:

module load biocontainers
module load clair3

Model_path

model_path is in /opt/models/. The parameter will be like this --model_path="/opt/models/MODEL_NAME"

Link to section 'Example job' of 'clair3' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clair3 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clair3
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clair3

run_clair3.sh \
      --bam_fn=input.bam \
      --ref_fn=ref.fasta \
      --threads=12 \
      --platform=ont \
      --model_path="/opt/models/ont" \
      --output=output

clairvoyante

Link to section 'Introduction' of 'clairvoyante' Introduction

Clairvoyante is a deep neural network based variant caller.

Docker hub: https://hub.docker.com/r/lifebitai/clairvoyante
Home page: https://github.com/aquaskyline/Clairvoyante

Link to section 'Versions' of 'clairvoyante' Versions

1.02

Link to section 'Commands' of 'clairvoyante' Commands

clairvoyante.py

Link to section 'Module' of 'clairvoyante' Module

You can load the modules by:

module load biocontainers
module load clairvoyante

Link to section 'Example job' of 'clairvoyante' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clairvoyante on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clairvoyante
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clairvoyante

cd training
clairvoyante.py callVarBam \
   --chkpnt_fn ../trainedModels/fullv3-illumina-novoalign-hg001+hg002-hg38/learningRate1e-3.epoch500 \
   --bam_fn ../testingData/chr21/chr21.bam \
   --ref_fn ../testingData/chr21/chr21.fa \
   --bed_fn ../testingData/chr21/chr21.bed \
   --call_fn chr21_calls.vcf \
   --ctgName chr21

clearcnv

Link to section 'Introduction' of 'clearcnv' Introduction

ClearCNV: CNV calling from NGS panel data in the presence of ambiguity and noise.

BioContainers: https://biocontainers.pro/tools/clearcnv
Home page: https://github.com/bihealth/clear-cnv

Link to section 'Versions' of 'clearcnv' Versions

0.306

Link to section 'Commands' of 'clearcnv' Commands

clearCNV

Link to section 'Module' of 'clearcnv' Module

You can load the modules by:

module load biocontainers
module load clearcnv

Link to section 'Example job' of 'clearcnv' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clearcnv on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clearcnv
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clearcnv

clever-toolkit

Link to section 'Introduction' of 'clever-toolkit' Introduction

Clever-toolkit is a collection of tools to discover and genotype structural variations in genomes from paired-end sequencing reads. The main software is written in C++ with some auxiliary scripts in Python.

BioContainers: https://biocontainers.pro/tools/clever-toolkit
Home page: https://bitbucket.org/tobiasmarschall/clever-toolkit/src/master/

Link to section 'Versions' of 'clever-toolkit' Versions

Link to section 'Module' of 'clever-toolkit' Module

You can load the modules by:

module load biocontainers
module load clever-toolkit

Link to section 'Example job' of 'clever-toolkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clever-toolkit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clever-toolkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clever-toolkit

cat mapped.bam |  bam2fastq output_1.fq output_2.fq

clonalframeml

Link to section 'Introduction' of 'clonalframeml' Introduction

ClonalFrameML is a software package that performs efficient inference of recombination in bacterial genomes.

BioContainers: https://biocontainers.pro/tools/clonalframeml
Home page: https://github.com/xavierdidelot/ClonalFrameML

Link to section 'Versions' of 'clonalframeml' Versions

1.11

Link to section 'Commands' of 'clonalframeml' Commands

ClonalFrameML

Link to section 'Module' of 'clonalframeml' Module

You can load the modules by:

module load biocontainers
module load clonalframeml

Link to section 'Example job' of 'clonalframeml' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clonalframeml on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clonalframeml
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clonalframeml

clust

Link to section 'Introduction' of 'clust' Introduction

Clust is a fully automated method for identification of clusters (groups) of genes that are consistently co-expressed (well-correlated) in one or more heterogeneous datasets from one or multiple species.

BioContainers: https://biocontainers.pro/tools/clust
Home page: https://github.com/baselabujamous/clust

Link to section 'Versions' of 'clust' Versions

1.17.0

Link to section 'Commands' of 'clust' Commands

clust

Link to section 'Module' of 'clust' Module

You can load the modules by:

module load biocontainers
module load clust

Link to section 'Example job' of 'clust' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run clust on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clust
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clust

clustalw

Link to section 'Introduction' of 'clustalw' Introduction

Clustalw is a general purpose multiple alignment program for DNA or proteins.

For more information, please check its website: https://biocontainers.pro/tools/clustalw and its home page: http://www.clustal.org/clustal2/.

Link to section 'Versions' of 'clustalw' Versions

Link to section 'Commands' of 'clustalw' Commands

clustalw

Link to section 'Module' of 'clustalw' Module

You can load the modules by:

module load biocontainers
module load clustalw

Link to section 'Example job' of 'clustalw' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Clustalw on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=clustalw
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers clustalw

clustalw -tree -align -infile=seq.faa

cnvkit

Link to section 'Introduction' of 'cnvkit' Introduction

CNVkit is a command-line toolkit and Python library for detecting copy number variants and alterations genome-wide from high-throughput sequencing.

For more information, please check its website: https://biocontainers.pro/tools/cnvkit and its home page on Github.

Link to section 'Versions' of 'cnvkit' Versions

0.9.9-py

Link to section 'Commands' of 'cnvkit' Commands

cnvkit.py
cnv_annotate.py
cnv_expression_correlate.py
cnv_updater.py

Link to section 'Module' of 'cnvkit' Module

You can load the modules by:

module load biocontainers
module load cnvkit

Link to section 'Example job' of 'cnvkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run CNVkit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cnvkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cnvkit

cnvkit.py batch *Tumor.bam --normal *Normal.bam \
                --targets my_baits.bed --fasta hg19.fasta \
                --access data/access-5kb-mappable.hg19.bed \
                --output-reference my_reference.cnn
                --output-dir example/

cnvnator

Link to section 'Introduction' of 'cnvnator' Introduction

Cnvnator is a tool for discovery and characterization of copy number variation (CNV) in population genome sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/cnvnator and its home page on Github.

Link to section 'Versions' of 'cnvnator' Versions

0.4.1

Link to section 'Commands' of 'cnvnator' Commands

cnvnator
cnvnator2VCF.pl
plotbaf.py
plotcircular.py
plotrdbaf.py
pytools.py

Link to section 'Module' of 'cnvnator' Module

You can load the modules by:

module load biocontainers
module load cnvnator

Link to section 'Example job' of 'cnvnator' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cnvnator on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cnvnator
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cnvnator

cnvnator -root file.root -tree file.bam -chrom $(seq 1 22) X Y

plotcircular.py file.root

coinfinder

Link to section 'Introduction' of 'coinfinder' Introduction

Coinfinder is an algorithm and software tool that detects genes which associate and dissociate with other genes more often than expected by chance in pangenomes.

BioContainers: https://biocontainers.pro/tools/coinfinder
Home page: https://github.com/fwhelan/coinfinder

Link to section 'Versions' of 'coinfinder' Versions

1.2.0

Link to section 'Commands' of 'coinfinder' Commands

coinfinder

Link to section 'Module' of 'coinfinder' Module

You can load the modules by:

module load biocontainers
module load coinfinder

Link to section 'Example job' of 'coinfinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run coinfinder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=coinfinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers coinfinder

coinfinder -i coinfinder-manuscript/gene_presence_absence.csv \
    -I -p coinfinder-manuscript/core-gps_fasttree.newick \
    -o output

concoct

CONCOCT: Clustering cONtigs with COverage and ComposiTion.

Detailed usage can be found here: https://github.com/BinPro/CONCOCT

Link to section 'Versions' of 'concoct' Versions

1.1.0

Link to section 'Commands' of 'concoct' Commands

concoct
concoct_refine
concoct_coverage_table.py
cut_up_fasta.py
extract_fasta_bins.py
merge_cutup_clustering.py

Link to section 'Module' of 'concoct' Module

You can load the modules by:

module load biocontainers
module load concoct/1.1.0-py38

Link to section 'Example job' of 'concoct' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run concoct on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=concoct
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers concoct/1.1.0-py38

cut_up_fasta.py final.contigs.fa -c 10000 -o 0 --merge_last -b contigs_10K.bed > contigs_10K.fa
concoct_coverage_table.py contigs_10K.bed SRR1976948_sorted.bam > coverage_table.tsv
concoct --composition_file contigs_10K.fa --coverage_file coverage_table.tsv -b concoct_output/

control-freec

Link to section 'Introduction' of 'control-freec' Introduction

Control-freec is a tool for detection of copy-number changes and allelic imbalances (including LOH) using deep-sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/control-freec and its home page on Github.

Link to section 'Versions' of 'control-freec' Versions

11.6

Link to section 'Commands' of 'control-freec' Commands

freec

Link to section 'Module' of 'control-freec' Module

You can load the modules by:

module load biocontainers
module load control-freec

Link to section 'Example job' of 'control-freec' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Control-freec on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=control-freec
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers control-freec

freec -conf config_chr19.txt

cooler

Link to section 'Introduction' of 'cooler' Introduction

Cooler is a support library for a sparse, compressed, binary persistent storage format, also called cooler, used to store genomic interaction data, such as Hi-C contact matrices.

For more information, please check its website: https://biocontainers.pro/tools/cooler and its home page on Github.

Link to section 'Versions' of 'cooler' Versions

0.8.11

Link to section 'Commands' of 'cooler' Commands

cooler
python
python3

Link to section 'Module' of 'cooler' Module

You can load the modules by:

module load biocontainers
module load Cooler

Link to section 'Interactive job' of 'cooler' Interactive job

To run Cooler interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers cooler
(base) UserID@bell-a008:~ $ python
Python 3.9.7 |  packaged by conda-forge |  (default, Sep 29 2021, 19:20:46) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import cooler

Link to section 'Batch job' of 'cooler' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cooler batch jobs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cooler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cooler

cooler info data/Rao2014-GM12878-MboI-allreps-filtered.1000kb.cool
cooler info -f bin-size data/Rao2014-GM12878-MboI-allreps-filtered.1000kb.cool
cooler info -m data/Rao2014-GM12878-MboI-allreps-filtered.1000kb.cool
cooler tree data/Rao2014-GM12878-MboI-allreps-filtered.1000kb.cool
cooler attrs data/Rao2014-GM12878-MboI-allreps-filtered.1000kb.cool

coverm

Link to section 'Introduction' of 'coverm' Introduction

Coverm is a configurable, easy to use and fast DNA read coverage and relative abundance calculator focused on metagenomics applications.

For more information, please check its website: https://biocontainers.pro/tools/coverm and its home page on Github.

Link to section 'Versions' of 'coverm' Versions

0.6.1

Link to section 'Commands' of 'coverm' Commands

coverm

Link to section 'Module' of 'coverm' Module

You can load the modules by:

module load biocontainers
module load coverm

Link to section 'Example job' of 'coverm' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Coverm on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=coverm
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers coverm

coverm  genome  --genome-fasta-files xcc.fasta  --coupled SRR11234553_1.fastq SRR11234553_2.fastq

cramino

Link to section 'Introduction' of 'cramino' Introduction

Cramino is a tool for quick quality assessment of cram and bam files, intended for long read sequencing.

Docker hub: https://hub.docker.com/r/alexanrna/cramino
Home page: https://github.com/wdecoster/cramino

Link to section 'Versions' of 'cramino' Versions

0.9.6

Link to section 'Commands' of 'cramino' Commands

cramino

Link to section 'Module' of 'cramino' Module

You can load the modules by:

module load biocontainers
module load cramino

Link to section 'Example job' of 'cramino' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cramino on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cramino
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cramino

crisprcasfinder

CRISPRCasFinder
==============================

CRISPRCasFinder enables the easy detection of CRISPRs and cas genes in user-submitted sequence data. It is an updated, improved, and integrated version of CRISPRFinder and CasFinder.

Detailed usage can be found here: https://github.com/dcouvin/CRISPRCasFinder

Link to section 'Versions' of 'crisprcasfinder' Versions

4.2.20

Link to section 'Commands' of 'crisprcasfinder' Commands

CRISPRCasFinder.pl

Link to section 'Module' of 'crisprcasfinder' Module

You can load the modules by:

module load biocontainers
module load crisprcasfinder/4.2.20

Link to section 'Example job' of 'crisprcasfinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run CRISPRCasFinder on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 2:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=CRISPRCasFinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers crisprcasfinder/4.2.20 

CRISPRCasFinder.pl -in install_test/sequence.fasta -cas -cf CasFinder-2.0.3 -def G -keep

crispresso2

Link to section 'Introduction' of 'crispresso2' Introduction

CRISPResso2 is a software pipeline designed to enable rapid and intuitive interpretation of genome editing experiments.

Docker hub: https://hub.docker.com/r/pinellolab/crispresso2
Home page: https://github.com/pinellolab/CRISPResso2

Link to section 'Versions' of 'crispresso2' Versions

2.2.10
2.2.11a
2.2.8
2.2.9

Link to section 'Commands' of 'crispresso2' Commands

CRISPResso
CRISPRessoAggregate
CRISPRessoBatch
CRISPRessoCompare
CRISPRessoPooled
CRISPRessoPooledWGSCompare
CRISPRessoWGS

Link to section 'Module' of 'crispresso2' Module

You can load the modules by:

module load biocontainers
module load crispresso2

Link to section 'Example job' of 'crispresso2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run crispresso2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=crispresso2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers crispresso2

CRISPResso --fastq_r1 nhej.r1.fastq.gz --fastq_r2 nhej.r2.fastq.gz -n nhej --amplicon_seq \
    AATGTCCCCCAATGGGAAGTTCATCTGGCACTGCCCACAGGTGAGGAGGTCATGATCCCCTTCTGGAGCTCCCAACGGGCCGTGGTCTGGTTCATCATCTGTAAGAATGGCTTCAAGAGGCTCGGCTGTGGTT

crispritz

Link to section 'Introduction' of 'crispritz' Introduction

Crispritz is a software package containing 5 different tools dedicated to perform predictive analysis and result assessment on CRISPR/Cas experiments.

For more information, please check its website: https://biocontainers.pro/tools/crispritz and its home page on Github.

Link to section 'Versions' of 'crispritz' Versions

2.6.5

Link to section 'Commands' of 'crispritz' Commands

crispritz.py

Link to section 'Module' of 'crispritz' Module

You can load the modules by:

module load biocontainers
module load crispritz

Link to section 'Example job' of 'crispritz' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Crispritz on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=crispritz
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers crispritz

crispritz.py add-variants hg38_1000genomeproject_vcf/ hg38_ref/ &> output.redirect.out 

crispritz.py index-genome hg38_ref hg38_ref/ 20bp-NGG-SpCas9.txt -bMax 2 &> output.redirect.out 

crispritz.py search hg38_ref/ 20bp-NGG-SpCas9.txt EMX1.sgRNA.txt emx1.hg38 -mm 4 -t -scores hg38_ref/ &> output.redirect.out

crispritz.py search genome_library/NGG_2_hg38_ref/ 20bp-NGG-SpCas9.txt EMX1.sgRNA.txt emx1.hg38.bulges -index -mm 4 -bDNA 1 -bRNA 1 -t &> output.redirect.out

crispritz.py annotate-results emx1.hg38.targets.txt hg38Annotation.bed emx1.hg38 &> output.redirect.out

cross_match

Link to section 'Introduction' of 'cross_match' Introduction

cross_match is a general purpose utility for comparing any two DNA sequence sets using a 'banded' version of swat.

For more information, please check its home page: http://www.phrap.org/phredphrapconsed.html#block_phrap.

Link to section 'Versions' of 'cross_match' Versions

1.090518

Link to section 'Commands' of 'cross_match' Commands

cross_match

Link to section 'Module' of 'cross_match' Module

You can load the modules by:

module load biocontainers
module load cross_match

Link to section 'Example job' of 'cross_match' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cross_match on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cross_match
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cross_match

crossmap

Link to section 'Introduction' of 'crossmap' Introduction

Crossmap is a program for genome coordinates conversion between different assemblies.

For more information, please check its website: https://biocontainers.pro/tools/crossmap and its home page: https://crossmap.readthedocs.io/en/latest/#convert-maf-format-files.

Link to section 'Versions' of 'crossmap' Versions

0.6.3

Link to section 'Commands' of 'crossmap' Commands

CrossMap.py

Link to section 'Module' of 'crossmap' Module

You can load the modules by:

module load biocontainers
module load crossmap

Link to section 'Example job' of 'crossmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Crossmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=crossmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers crossmap

CrossMap.py bed GRCh37_to_GRCh38.chain.gz test.bed

csvtk

Link to section 'Introduction' of 'csvtk' Introduction

Csvtk is a cross-platform, efficient and practical CSV/TSV toolkit.

For more information, please check its website: https://biocontainers.pro/tools/csvtk and its home page on Github.

Link to section 'Versions' of 'csvtk' Versions

0.23.0
0.25.0

Link to section 'Commands' of 'csvtk' Commands

csvtk

Link to section 'Module' of 'csvtk' Module

You can load the modules by:

module load biocontainers
module load csvtk

Link to section 'Example job' of 'csvtk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Csvtk on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=csvtk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers csvtk

cat data.csv \
 |  csvtk summary --ignore-non-digits --fields f4:sum,f5:sum --groups f1,f2 \
 |  csvtk pretty

cufflinks

Link to section 'Introduction' of 'cufflinks' Introduction

Cufflinks assembles transcripts, estimates their abundances, and tests for differential expression and regulation in RNA-Seq samples. It accepts aligned RNA-Seq reads and assembles the alignments into a parsimonious set of transcripts. Cufflinks then estimates the relative abundances of these transcripts based on how many reads support each one, taking into account biases in library preparation protocols.

For more information, please check its website: https://biocontainers.pro/tools/cufflinks and its home page on Github.

Link to section 'Versions' of 'cufflinks' Versions

2.2.1

Link to section 'Module' of 'cufflinks' Module

You can load the modules by:

module load biocontainers
module load cufflinks

Link to section 'Example job' of 'cufflinks' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cufflinks on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=cufflinks
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cufflinks

cufflinks -p 8 -G transcript.gtf --library-type fr-unstranded -o cufflinks_output tophat_out/accepted_hits.bam

cutadapt

Link to section 'Introduction' of 'cutadapt' Introduction

Cutadapt finds and removes adapter sequences, primers, poly-A tails and other types of unwanted sequence from your high-throughput sequencing reads.

For more information, please check its website: https://biocontainers.pro/tools/cutadapt and its home page: https://cutadapt.readthedocs.io/en/stable/.

Link to section 'Versions' of 'cutadapt' Versions

Link to section 'Commands' of 'cutadapt' Commands

cutadapt

Link to section 'Module' of 'cutadapt' Module

You can load the modules by:

module load biocontainers
module load cutadapt

Link to section 'Example job' of 'cutadapt' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cutadapt on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cutadapt
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cutadapt


cutadapt -a AACCGGTT -o output.fastq input.fastq

cuttlefish

Link to section 'Introduction' of 'cuttlefish' Introduction

Cuttlefish is a fast, parallel, and very lightweight memory tool to construct the compacted de Bruijn graph from sequencing reads or reference sequences. It is highly scalable in terms of the size of the input data.

BioContainers: https://biocontainers.pro/tools/cuttlefish
Home page: https://github.com/COMBINE-lab/cuttlefish

Link to section 'Versions' of 'cuttlefish' Versions

2.1.1

Link to section 'Commands' of 'cuttlefish' Commands

cuttlefish

Link to section 'Module' of 'cuttlefish' Module

You can load the modules by:

module load biocontainers
module load cuttlefish

Link to section 'Example job' of 'cuttlefish' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run cuttlefish on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cuttlefish
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cuttlefish

cyvcf2

Link to section 'Introduction' of 'cyvcf2' Introduction

Cyvcf2 is a cython wrapper around htslib built for fast parsing of Variant Call Format (VCF) files.

For more information, please check its website: https://biocontainers.pro/tools/cyvcf2 and its home page on Github.

Link to section 'Versions' of 'cyvcf2' Versions

0.30.14

Link to section 'Commands' of 'cyvcf2' Commands

cyvcf2
python
python3

Link to section 'Module' of 'cyvcf2' Module

You can load the modules by:

module load biocontainers
module load cyvcf2

Link to section 'Interactive job' of 'cyvcf2' Interactive job

To run Cyvcf2 interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n1 -t1:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers scanpy/1.8.2
(base) UserID@bell-a008:~ $ python
Python 3.7.12 |  packaged by conda-forge |  (default, Oct 26 2021, 06:08:53) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from cyvcf2 import VCF

Link to section 'Batch job' of 'cyvcf2' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Cyvcf2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=cyvcf2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers cyvcf2

cyvcf2 --help 
cyvcf2 [OPTIONS] <vcf_file>

das_tool

Link to section 'Introduction' of 'das_tool' Introduction

DAS Tool is an automated method that integrates the results of a flexible number of binning algorithms to calculate an optimized, non-redundant set of bins from a single assembly.

BioContainers: https://biocontainers.pro/tools/das_tool
Home page: https://github.com/cmks/DAS_Tool

Link to section 'Versions' of 'das_tool' Versions

1.1.6

Link to section 'Commands' of 'das_tool' Commands

DAS_Tool
Contigs2Bin_to_Fasta.sh
Fasta_to_Contig2Bin.sh
get_species_taxids.sh

Link to section 'Module' of 'das_tool' Module

You can load the modules by:

module load biocontainers
module load das_tool

Link to section 'Example job' of 'das_tool' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run das_tool on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=das_tool
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers das_tool

DAS_Tool -i sample.human.gut_concoct_contigs2bin.tsv,\
    sample.human.gut_maxbin2_contigs2bin.tsv,\
    sample.human.gut_metabat_contigs2bin.tsv,\
    sample.human.gut_tetraESOM_contigs2bin.tsv \
    -l concoct,maxbin,metabat,tetraESOM \
    -c sample.human.gut_contigs.fa \
    -o DASToolRun2 \
    --proteins DASToolRun1_proteins.faa \
    --write_bin_evals \
    --threads 4 \
    --score_threshold 0.6

dbg2olc

Link to section 'Introduction' of 'dbg2olc' Introduction

Dbg2olc is used for efficient assembly of large genomes using long erroneous reads of the third generation sequencing technologies.

For more information, please check its website: https://biocontainers.pro/tools/dbg2olc and its home page on Github.

Link to section 'Versions' of 'dbg2olc' Versions

20180222
20200723

Link to section 'Module' of 'dbg2olc' Module

You can load the modules by:

module load biocontainers
module load dbg2olc

Link to section 'Example job' of 'dbg2olc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Dbg2olc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=dbg2olc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dbg2olc

SelectLongestReads sum 600000000 longest 0 o TEST.fq f SRR1976948.abundtrim.subset.pe.fq

deconseq

Link to section 'Introduction' of 'deconseq' Introduction

DeconSeq: DECONtamination of SEQuence data using a modified version of BWA-SW. The DeconSeq tool can be used to automatically detect and efficiently remove sequence contamination from genomic and metagenomic datasets. It is easily configurable and provides a user-friendly interface.

Home page: http://deconseq.sourceforge.net/

Link to section 'Versions' of 'deconseq' Versions

0.4.3

Link to section 'Commands' of 'deconseq' Commands

bwa64
deconseq.pl
splitFasta.pl

Link to section 'Module' of 'deconseq' Module

You can load the modules by:

module load biocontainers
module load deconseq

Helper command

Users need to use DeconSeqConfig.pm to specify the database information. Besides, for the current deconseq module in `biocontainers`, users need to copy the executables to your current directory, including bwa64, deconseq.pl, and splitFasta.pl. This step is only needed to run once.

A helper command copy_DeconSeqConfig is provided to copy the configuration file DeconSeqConfig.pm and executables to your current directory. You just need to run the command copy_DeconSeqConfig and modify DeconSeqConfig.pm as needed:

copy_DeconSeqConfig
nano DeconSeqConfig.pm # modify database information as needed

For detailed information about how to config DeconSeqConfig.pm, please check its online manual (https://sourceforge.net/projects/deconseq/files/).

Link to section 'Example job' of 'deconseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run deconseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=deconseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deconseq

bwa64 index -p hg38_db -a bwtsw Homo_sapiens.GRCh38.dna.fa
bwa64 index -p m39_db -a bwtsw GRCm38.p4.genome.fa 
deconseq.pl -f input.fastq -dbs hg38_db -dbs_retain m39_db

deepbgc

Link to section 'Introduction' of 'deepbgc' Introduction

Deepbgc is a tool for BGC detection and classification using deep learning.

For more information, please check its website: https://biocontainers.pro/tools/deepbgc and its home page on Github.

Link to section 'Versions' of 'deepbgc' Versions

0.1.26
0.1.30

Link to section 'Commands' of 'deepbgc' Commands

deepbgc

Link to section 'Module' of 'deepbgc' Module

You can load the modules by:

module load biocontainers
module load deepbgc

Link to section 'Example job' of 'deepbgc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Deepbgc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=deepbgc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deepbgc

export DEEPBGC_DOWNLOADS_DIR=$PWD
deepbgc download
deepbgc pipeline genome.fa  -o output

deepconsensus

Link to section 'Introduction' of 'deepconsensus' Introduction

DeepConsensus uses gap-aware sequence transformers to correct errors in Pacific Biosciences (PacBio) Circular Consensus Sequencing (CCS) data.

Docker hub: https://hub.docker.com/r/google/deepconsensus
Home page: https://github.com/google/deepconsensus

Link to section 'Versions' of 'deepconsensus' Versions

0.2.0

Link to section 'Commands' of 'deepconsensus' Commands

deepconsensus
ccs
actc

Link to section 'Module' of 'deepconsensus' Module

You can load the modules by:

module load biocontainers
module load deepconsensus

Link to section 'Example job' of 'deepconsensus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run deepconsensus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=deepconsensus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deepconsensus

deepconsensus run \
    --subreads_to_ccs=subreads_to_ccs.bam  \
    --ccs_fasta=ccs.fasta \
    --checkpoint=checkpoint-50 \
    --output=output.fastq \
    --batch_zmws=100

deepsignal2

Link to section 'Introduction' of 'deepsignal2' Introduction

Deepsignal2 is a deep-learning method for detecting DNA methylation state from Oxford Nanopore sequencing reads.

For more information, please check its home page on Github.

Link to section 'Versions' of 'deepsignal2' Versions

0.1.2

Link to section 'Module' of 'deepsignal2' Module

You can load the modules by:

module load biocontainers
module load deepsignal2

Link to section 'Example job' of 'deepsignal2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Deepsignal2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=deepsignal2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deepsignal2

deeptools

Link to section 'Introduction' of 'deeptools' Introduction

DeepTools is a collection of user-friendly tools for normalization and visualization of deep-sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/deeptools and its home page on Github.

Link to section 'Versions' of 'deeptools' Versions

3.5.1-py

Link to section 'Module' of 'deeptools' Module

You can load the modules by:

module load biocontainers
module load deeptools

Link to section 'Example job' of 'deeptools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run DeepTools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=deeptools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deeptools

bamCoverage  --normalizeUsing CPM -p 32  \
     --effectiveGenomeSize  11000000  \
     -b WT_coord_sorted.bam  \
     -o WT_coord_sorted.bw

deepvariant

Link to section 'Introduction' of 'deepvariant' Introduction

DeepVariant is a deep learning-based variant caller that takes aligned reads (in BAM or CRAM format), produces pileup image tensors from them, classifies each tensor using a convolutional neural network, and finally reports the results in a standard VCF or gVCF file.

Home page: https://github.com/google/deepvariant

Link to section 'Versions' of 'deepvariant' Versions

1.0.0
1.1.0

Link to section 'Module' of 'deepvariant' Module

You can load the modules by:

module load biocontainers
module load deepvariant

Link to section 'Example job' of 'deepvariant' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run deepvariant on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=deepvariant
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers deepvariant

INPUT_DIR="${PWD}/quickstart-testdata"
DATA_HTTP_DIR="https://storage.googleapis.com/deepvariant/quickstart-testdata"
mkdir -p ${INPUT_DIR}
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/NA12878_S1.chr20.10_10p1mb.bam
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/NA12878_S1.chr20.10_10p1mb.bam.bai
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/test_nist.b37_chr20_100kbp_at_10mb.bed
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/test_nist.b37_chr20_100kbp_at_10mb.vcf.gz
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/test_nist.b37_chr20_100kbp_at_10mb.vcf.gz.tbi
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/ucsc.hg19.chr20.unittest.fasta
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/ucsc.hg19.chr20.unittest.fasta.fai
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/ucsc.hg19.chr20.unittest.fasta.gz
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/ucsc.hg19.chr20.unittest.fasta.gz.fai
wget -P ${INPUT_DIR} "${DATA_HTTP_DIR}"/ucsc.hg19.chr20.unittest.fasta.gz.gzi
   
run_deepvariant --model_type=WGS --ref="${INPUT_DIR}"/ucsc.hg19.chr20.unittest.fasta  --reads="${INPUT_DIR}"/NA12878_S1.chr20.10_10p1mb.bam  --regions "chr20:10,000,000-10,010,000"  --output_vcf="output/output.vcf.gz"  --output_gvcf="output/output.g.vcf.gz" --intermediate_results_dir "output/intermediate_results_dir"  --num_shards=4

delly

Link to section 'Introduction' of 'delly' Introduction

Delly is an integrated structural variant (SV) prediction method that can discover, genotype and visualize deletions, tandem duplications, inversions and translocations at single-nucleotide resolution in short-read massively parallel sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/delly and its home page on Github.

Link to section 'Versions' of 'delly' Versions

0.9.1
1.0.3
1.1.3
1.1.5
1.1.6

Link to section 'Commands' of 'delly' Commands

delly

Link to section 'Module' of 'delly' Module

You can load the modules by:

module load biocontainers
module load delly

Link to section 'Example job' of 'delly' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Delly on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=delly
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers delly

delly call -x hg19.excl -o delly.bcf -g hg19.fa input.bam
delly filter -f somatic -o t1.pre.bcf -s samples.tsv t1.bcf

dendropy

Link to section 'Introduction' of 'dendropy' Introduction

DendroPy is a Python library for phylogenetic computing. It provides classes and functions for the simulation, processing, and manipulation of phylogenetic trees and character matrices, and supports the reading and writing of phylogenetic data in a range of formats, such as NEXUS, NEWICK, NeXML, Phylip, FASTA, etc. Application scripts for performing some useful phylogenetic operations, such as data conversion and tree posterior distribution summarization, are also distributed and installed as part of the library. DendroPy can thus function as a stand-alone library for phylogenetics, a component of more complex multi-library phyloinformatic pipelines, or as a scripting "glue" that assembles and drives such pipelines.

BioContainers: https://biocontainers.pro/tools/dendropy
Home page: https://github.com/jeetsukumaran/DendroPy

Link to section 'Versions' of 'dendropy' Versions

4.5.2

Link to section 'Commands' of 'dendropy' Commands

python
python3 -
-
sumtrees.py

Link to section 'Module' of 'dendropy' Module

You can load the modules by:

module load biocontainers
module load dendropy

Link to section 'Example job' of 'dendropy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run dendropy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=dendropy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dendropy

diamond

Diamond is a sequence aligner for protein and translated DNA searches, designed for high performance analysis of big sequence data. The key features are:

Pairwise alignment of proteins and translated DNA at 100x-10,000x speed of BLAST.
Frameshift alignments for long read analysis.
Low resource requirements and suitable for running on standard desktops or laptops.
Various output formats, including BLAST pairwise, tabular and XML, as well as taxonomic classification.

Detailed about its usage can be found here: https://github.com/bbuchfink/diamond

Link to section 'Versions' of 'diamond' Versions

2.0.13
2.0.14
2.0.15

Link to section 'Module' of 'diamond' Module

You can load the modules by:

module load biocontainers
module load diamond/2.0.14

Link to section 'Example job' of 'diamond' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run diamond on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=diamond
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers diamond/2.0.14

diamond makedb  --in uniprot_sprot.fasta -d uniprot_sprot
diamond blastp -p 24 -q test.faa -d uniprot_sprot  --very-sensitive -o blastp_output.txt

dnaio

Link to section 'Introduction' of 'dnaio' Introduction

Dnaio is a Python 3.7+ library for very efficient parsing and writing of FASTQ and also FASTA files.

For more information, please check its website: https://biocontainers.pro/tools/dnaio and its home page on Github.

Link to section 'Versions' of 'dnaio' Versions

0.8.1

Link to section 'Commands' of 'dnaio' Commands

python
python3

Link to section 'Module' of 'dnaio' Module

You can load the modules by:

module load biocontainers
module load dnaio

Link to section 'Example job' of 'dnaio' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Dnaio on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=dnaio
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dnaio

python dnaio_test.py

dragonflye

Link to section 'Introduction' of 'dragonflye' Introduction

Dragonflye is a pipeline that aims to make assembling Oxford Nanopore reads quick and easy.

BioContainers: https://biocontainers.pro/tools/dragonflye
Home page: https://github.com/rpetit3/dragonflye

Link to section 'Versions' of 'dragonflye' Versions

1.0.13
1.0.14

Link to section 'Commands' of 'dragonflye' Commands

dragonflye

Link to section 'Module' of 'dragonflye' Module

You can load the modules by:

module load biocontainers
module load dragonflye

Link to section 'Example job' of 'dragonflye' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run dragonflye on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=dragonflye
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dragonflye

dragonflye --cpus 8 \
     --outdir output \
     --reads SRR18498195.fastq

drep

Link to section 'Introduction' of 'drep' Introduction

Drep is a python program for rapidly comparing large numbers of genomes.

For more information, please check its website: https://biocontainers.pro/tools/drep and its home page on Github.

Link to section 'Versions' of 'drep' Versions

3.2.2

Link to section 'Commands' of 'drep' Commands

dRep

Link to section 'Module' of 'drep' Module

You can load the modules by:

module load biocontainers
module load drep

Link to section 'Example job' of 'drep' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Drep on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=drep
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers drep

dRep compare compare_out -g tests/genomes/*
dRep dereplicate dereplicate_out -g tests/genomes/*

drop-seq

Link to section 'Introduction' of 'drop-seq' Introduction

Drop-seq are java tools for analyzing Drop-seq data.

Home page: https://github.com/broadinstitute/Drop-seq

Link to section 'Versions' of 'drop-seq' Versions

2.5.2

Link to section 'Module' of 'drop-seq' Module

You can load the modules by:

module load biocontainers
module load drop-seq

Link to section 'Example job' of 'drop-seq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run drop-seq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=drop-seq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers drop-seq

dropest

Link to section 'Introduction' of 'dropest' Introduction

Dropest is a pipeline for initial analysis of droplet-based single-cell RNA-seq data.

For more information, please check its website: https://biocontainers.pro/tools/dropest and its home page on Github.

Link to section 'Versions' of 'dropest' Versions

0.8.6

Link to section 'Commands' of 'dropest' Commands

dropest
droptag
dropReport.Rsc
R
Rscript

Link to section 'Module' of 'dropest' Module

You can load the modules by:

module load biocontainers
module load dropest

Link to section 'Example job' of 'dropest' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Dropest on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=dropest
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dropest

dropest -f -c 10x.xml  -C 1200 neurons_900_possorted_genome_bam.bam

dsuite

Link to section 'Introduction' of 'dsuite' Introduction

Dsuite is a fast C++ implementation, allowing genome scale calculations of the D and f4-ratio statistics across all combinations of tens or hundreds of populations or species directly from a variant call format (VCF) file.

For more information, please check its home page on Github.

Link to section 'Versions' of 'dsuite' Versions

0.4.r43
0.5.r44

Link to section 'Commands' of 'dsuite' Commands

Dsuite
dtools.py
DtriosParallel

Link to section 'Module' of 'dsuite' Module

You can load the modules by:

module load biocontainers
module load dsuite

Link to section 'Example job' of 'dsuite' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Dsuite on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=dsuite
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers dsuite

Dsuite Dtrios -c -n no_geneflow -t simulated_tree_no_geneflow.nwk chr1_no_geneflow.vcf.gz species_sets.txt

easysfs

Link to section 'Introduction' of 'easysfs' Introduction

easySFS is a tool for the effective selection of population size projection for construction of the site frequency spectrum.

For more information, please check its home page on Github.

Link to section 'Versions' of 'easysfs' Versions

Link to section 'Commands' of 'easysfs' Commands

easySFS.py

Link to section 'Module' of 'easysfs' Module

You can load the modules by:

module load biocontainers
module load easysfs

Link to section 'Example job' of 'easysfs' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run easySFS on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=easysfs
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers easysfs

easySFS.py -i example_files/wcs_1200.vcf -p example_files/wcs_pops.txt --preview -a
easySFS.py -i example_files/wcs_1200.vcf -p example_files/wcs_pops.txt -a --proj=7,7

edta

Link to section 'Introduction' of 'edta' Introduction

Edta is is developed for automated whole-genome de-novo TE annotation and benchmarking the annotation performance of TE libraries.

For more information, please check its website: https://biocontainers.pro/tools/edta and its home page on Github.

Note: Running EDTA, please use the command like this: EDTA.pl [OPTIONS] DO NOT call it 'perl EDTA.pl'

Link to section 'Versions' of 'edta' Versions

1.9.6
2.0.0

Link to section 'Module' of 'edta' Module

You can load the modules by:

module load biocontainers
module load edta

Link to section 'Example job' of 'edta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Edta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 10
#SBATCH --job-name=edta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers edta

EDTA.pl --genome genome.fa --cds genome.cds.fa --curatedlib EDTA/database/rice6.9.5.liban --exclude genome.exclude.bed --overwrite 1 --sensitive 1 --anno 1 --evaluate 1 --threads 10

eggnog-mapper

Link to section 'Introduction' of 'eggnog-mapper' Introduction

Eggnog-mapper is a tool for fast functional annotation of novel sequences.

For more information, please check its website: https://biocontainers.pro/tools/eggnog-mapper and its home page on Github.

Link to section 'Versions' of 'eggnog-mapper' Versions

2.1.7

Link to section 'Commands' of 'eggnog-mapper' Commands

create_dbs.py
download_eggnog_data.py
emapper.py
hmm_mapper.py
hmm_server.py
hmm_worker.py
vba_extract.py

Link to section 'Module' of 'eggnog-mapper' Module

You can load the modules by:

module load biocontainers
module load eggnog-mapper

Link to section 'Example job' of 'eggnog-mapper' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Eggnog-mapper on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=eggnog-mapper
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers eggnog-mapper

emapper.py -i proteins.faa --cpu 24 -o protein.out
emapper.py -m diamond --itype CDS -i cDNA.fasta -o cdna.out --cpu 24

emboss

Link to section 'Introduction' of 'emboss' Introduction

Emboss is "The European Molecular Biology Open Software Suite".

For more information, please check its website: https://biocontainers.pro/tools/emboss and its home page: http://emboss.open-bio.org.

Link to section 'Versions' of 'emboss' Versions

6.6.0

Link to section 'Module' of 'emboss' Module

You can load the modules by:

module load biocontainers
module load emboss

Link to section 'Example job' of 'emboss' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Emboss on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=emboss
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers emboss

ensembl-vep

Link to section 'Introduction' of 'ensembl-vep' Introduction

Ensembl-vep(Ensembl Variant Effect Predictor) predicts the functional effects of genomic variants.

Docker hub: https://hub.docker.com/r/ensemblorg/ensembl-vep
Home page: https://github.com/Ensembl/ensembl-vep

Link to section 'Versions' of 'ensembl-vep' Versions

106.1
107.0
108.2

Link to section 'Commands' of 'ensembl-vep' Commands

vep
haplo
variant_recoder

Link to section 'Module' of 'ensembl-vep' Module

You can load the modules by:

module load biocontainers
module load ensembl-vep

Link to section 'Example job' of 'ensembl-vep' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ensembl-vep on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ensembl-vep
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ensembl-vep

haplo -i bos_taurus_UMD3.1.vcf -o out.txt

epic2

Link to section 'Introduction' of 'epic2' Introduction

Epic2 is an ultraperformant Chip-Seq broad domain finder based on SICER.

For more information, please check its website: https://biocontainers.pro/tools/epic2 and its home page on Github.

Link to section 'Versions' of 'epic2' Versions

0.0.51
0.0.52

Link to section 'Commands' of 'epic2' Commands

epic2
epic2-bw
epic2-df

Link to section 'Module' of 'epic2' Module

You can load the modules by:

module load biocontainers
module load epic2

Link to section 'Example job' of 'epic2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Epic2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=epic2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers epic2

epic2 -t /examples/test.bed.gz \
  -c /examples/control.bed.gz \
  > deleteme.txt

evidencemodeler

Link to section 'Introduction' of 'evidencemodeler' Introduction

Evidencemodeler is a software combines ab intio gene predictions and protein and transcript alignments into weighted consensus gene structures.

For more information, please check its website: https://biocontainers.pro/tools/evidencemodeler and its home page on Github.

Link to section 'Versions' of 'evidencemodeler' Versions

1.1.1

Link to section 'Module' of 'evidencemodeler' Module

You can load the modules by:

module load biocontainers
module load evidencemodeler

Link to section 'Example job' of 'evidencemodeler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Evidencemodeler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=evidencemodeler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers evidencemodeler


evidence_modeler.pl --genome genome.fasta \
                   --weights weights.txt \
                   --gene_predictions gene_predictions.gff3 \
                   --protein_alignments protein_alignments.gff3 \
                   --transcript_alignments transcript_alignments.gff3 \
                 > evm.out

exonerate

Link to section 'Introduction' of 'exonerate' Introduction

Exonerate is a generic tool for pairwise sequence comparison/alignment.

For more information, please check its home page: https://www.ebi.ac.uk/about/vertebrate-genomics/software/exonerate.

Link to section 'Versions' of 'exonerate' Versions

2.4.0

Link to section 'Commands' of 'exonerate' Commands

exonerate

Link to section 'Module' of 'exonerate' Module

You can load the modules by:

module load biocontainers
module load exonerate

Link to section 'Example job' of 'exonerate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Exonerate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=exonerate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers exonerate

exonerate  -m genome2genome  cms.fasta cmm.fasta > cm_vs_cs.out

expansionhunter

Link to section 'Introduction' of 'expansionhunter' Introduction

Expansion Hunter: a tool for estimating repeat sizes.

BioContainers: https://biocontainers.pro/tools/expansionhunter
Home page: https://github.com/Illumina/ExpansionHunter

Link to section 'Versions' of 'expansionhunter' Versions

4.0.2

Link to section 'Commands' of 'expansionhunter' Commands

ExpansionHunter

Link to section 'Module' of 'expansionhunter' Module

You can load the modules by:

module load biocontainers
module load expansionhunter

Link to section 'Example job' of 'expansionhunter' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run expansionhunter on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=expansionhunter
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers expansionhunter

fasta3

Link to section 'Introduction' of 'fasta3' Introduction

Fasta3 is a suite of programs for searching nucleotide or protein databases with a query sequence.

For more information, please check its website: https://biocontainers.pro/tools/fasta3 and its home page on Github.

Link to section 'Versions' of 'fasta3' Versions

36.3.8

Link to section 'Module' of 'fasta3' Module

You can load the modules by:

module load biocontainers
module load fasta3

Link to section 'Example job' of 'fasta3' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fasta3 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fasta3
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fasta3

fasta36 input.fasta genome.fasta

fastani

Link to section 'Introduction' of 'fastani' Introduction

FastANI is developed for fast alignment-free computation of whole-genome Average Nucleotide Identity (ANI).

For more information, please check its website: https://biocontainers.pro/tools/fastani and its home page on Github.

Link to section 'Versions' of 'fastani' Versions

1.32
1.33

Link to section 'Commands' of 'fastani' Commands

fastANI

Link to section 'Module' of 'fastani' Module

You can load the modules by:

module load biocontainers
module load fastani

Link to section 'Example job' of 'fastani' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run FastANI on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastani
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastani

fastANI -q cmm.fasta -r cms.fasta -o cm_cs_out 

fastANI -q cmm.fasta -r cms.fasta  --visualize -o cm_cs_visualize_out

fastp

Link to section 'Introduction' of 'fastp' Introduction

Fastp is an ultra-fast all-in-one FASTQ preprocessor (QC/adapters/trimming/filtering/splitting/merging, etc).

For more information, please check its website: https://biocontainers.pro/tools/fastp and its home page on Github.

Link to section 'Versions' of 'fastp' Versions

0.20.1
0.23.2

Link to section 'Commands' of 'fastp' Commands

fastp

Link to section 'Module' of 'fastp' Module

You can load the modules by:

module load biocontainers
module load fastp

Link to section 'Example job' of 'fastp' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fastp on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastp
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastp

fastp -i input_1.fastq  -I input_2.fastq -o out.R1.fq.gz -O out.R2.fq.gz

fastq-scan

Link to section 'Introduction' of 'fastq-scan' Introduction

Fastq-scan reads a FASTQ from STDIN and outputs summary statistics (read lengths, per-read qualities, per-base qualities) in JSON format.

Docker hub: https://hub.docker.com/r/staphb/fastq-scan
Home page: https://github.com/rpetit3/fastq-scan

Link to section 'Versions' of 'fastq-scan' Versions

1.0.0

Link to section 'Commands' of 'fastq-scan' Commands

fastq-scan

Link to section 'Module' of 'fastq-scan' Module

You can load the modules by:

module load biocontainers
module load fastq-scan

Link to section 'Example job' of 'fastq-scan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run fastq-scan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastq-scan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastq-scan

cat example-q33.fq | fastq-scan -g 150000

fastq_pair

Link to section 'Introduction' of 'fastq_pair' Introduction

Fastq_pair is used to match up paired end fastq files quickly and efficiently.

For more information, please check its website: https://biocontainers.pro/tools/fastq_pair and its home page on Github.

Link to section 'Versions' of 'fastq_pair' Versions

Link to section 'Commands' of 'fastq_pair' Commands

fastq_pair

Link to section 'Module' of 'fastq_pair' Module

You can load the modules by:

module load biocontainers
module load fastq_pair

Link to section 'Example job' of 'fastq_pair' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fastq_pair on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastq_pair
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastq_pair

fastq_pair seq_1.fastq  seq_2.fastq

fastqc

Link to section 'Introduction' of 'fastqc' Introduction

FastQC aims to provide a simple way to do some quality control checks on raw sequence data coming from high throughput sequencing pipelines. It provides a modular set of analyses which you can use to give a quick impression of whether your data has any problems of which you should be aware before doing any further analysis.

For more information, please check its website: https://biocontainers.pro/tools/fastqc and its home page: https://www.bioinformatics.babraham.ac.uk/projects/fastqc/.

Link to section 'Versions' of 'fastqc' Versions

0.11.9

Link to section 'Commands' of 'fastqc' Commands

fastqc

Link to section 'Module' of 'fastqc' Module

You can load the modules by:

module load biocontainers
module load fastqc

Link to section 'Example job' of 'fastqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fastqc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=fastqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastqc

fastqc -o fastqc_out -t 4 FASTQ1 FASTQ2

fastspar

Link to section 'Introduction' of 'fastspar' Introduction

Fastspar is a tool for rapid and scalable correlation estimation for compositional data.

For more information, please check its website: https://biocontainers.pro/tools/fastspar and its home page on Github.

Link to section 'Versions' of 'fastspar' Versions

1.0.0

Link to section 'Commands' of 'fastspar' Commands

fastspar
fastspar_bootstrap
fastspar_pvalues
fastspar_reduce

Link to section 'Module' of 'fastspar' Module

You can load the modules by:

module load biocontainers
module load fastspar

Link to section 'Example job' of 'fastspar' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fastspar on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastspar
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastspar

faststructure

Link to section 'Introduction' of 'faststructure' Introduction

fastStructure is an algorithm for inferring population structure from large SNP genotype data. It is based on a variational Bayesian framework for posterior inference and is written in Python2.x.

Note: programs "structure.py", "chooseK.py" and "distruct.py" are standalone executable and should be called by name directly ("structure.py", etc). DO NOT invoke them as "python structure.py", or as "python /usr/local/bin/structure.py", this will not work!

Note: This containers lacks X11 libraries, so GUI plots with 'distruct.py' do not work. Instead, we need to tell the underlying Matplotlib to use a non-interactive plotting backend (to file). The easiest and most flexible way is to use the MPLBACKEND environment variable: env MPLBACKEND="svg" distruct.py --output myplot.svg .......

Available backends in this container: Backend Filetypes Description agg png raster graphics – high quality PNG output ps ps eps vector graphics – Postscript output pdf pdf vector graphics – Portable Document Format svg svg vector graphics – Scalable Vector Graphics Default MPLBACKEND="agg" (for PNG format output).

For more information, please check its website: https://biocontainers.pro/tools/faststructure and its home page on Github.

Link to section 'Versions' of 'faststructure' Versions

1.0-py27

Link to section 'Commands' of 'faststructure' Commands

structure.py
chooseK.py
distruct.py

Link to section 'Module' of 'faststructure' Module

You can load the modules by:

module load biocontainers
module load faststructure

Link to section 'Example job' of 'faststructure' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run fastStructure on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=faststructure
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers faststructure

fasttree

Link to section 'Introduction' of 'fasttree' Introduction

FastTree infers approximately-maximum-likelihood phylogenetic trees from alignments of nucleotide or protein sequences. FastTree can handle alignments with up to a million of sequences in a reasonable amount of time and memory.

Detailed usage can be found here: http://www.microbesonline.org/fasttree/

2.1.10
2.1.11

Link to section 'Commands' of 'fasttree' Commands

fasttree
FastTree
FastTreeMP

fasttree and FastTree are the same program, and they only support one CPU. If you want to use multiple CPUs, please use FastTreeMP and also set the OMP_NUM_THREADS to the number of cores you requested.

Link to section 'Module' of 'fasttree' Module

You can load the modules by:

module load biocontainers
module load fasttree

Link to section 'Example job using single CPU' of 'fasttree' Example job using single CPU

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run FastTree on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fasttree
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fasttree

FastTree alignmentfile > treefile

Link to section 'Example job using multiple CPUs' of 'fasttree' Example job using multiple CPUs

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run FastTree on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=FastTreeMP
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fasttree

export OMP_NUM_THREADS=24

FastTreeMP alignmentfile > treefile

fastx_toolkit

Link to section 'Introduction' of 'fastx_toolkit' Introduction

FASTX-Toolkit is a collection of command line tools for Short-Reads FASTA/FASTQ files preprocessing.

For more information, please check its website: https://biocontainers.pro/tools/fastx_toolkit and its home page on Github.

Link to section 'Versions' of 'fastx_toolkit' Versions

0.0.14

Link to section 'Module' of 'fastx_toolkit' Module

You can load the modules by:

module load biocontainers
module load fastx_toolkit

Link to section 'Example job' of 'fastx_toolkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run FASTX-Toolkit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fastx_toolkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fastx_toolkit

filtlong

Link to section 'Introduction' of 'filtlong' Introduction

Filtlong is a tool for filtering long reads by quality. It can take a set of long reads and produce a smaller, better subset. It uses both read length (longer is better) and read identity (higher is better) when choosing which reads pass the filter.

For more information, please check its website: https://biocontainers.pro/tools/filtlong and its home page on Github.

Link to section 'Versions' of 'filtlong' Versions

0.2.1

Link to section 'Commands' of 'filtlong' Commands

filtlong

Link to section 'Module' of 'filtlong' Module

You can load the modules by:

module load biocontainers
module load filtlong

Link to section 'Example job' of 'filtlong' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Filtlong on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=filtlong
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers filtlong

flye

Link to section 'Introduction' of 'flye' Introduction

Flye: Fast and accurate de novo assembler for single molecule sequencing reads.

For more information, please check its website: https://biocontainers.pro/tools/flye and its home page on Github.

Link to section 'Versions' of 'flye' Versions

2.9.1
2.9

Link to section 'Commands' of 'flye' Commands

flye

Link to section 'Module' of 'flye' Module

You can load the modules by:

module load biocontainers
module load flye

Link to section 'Example job' of 'flye' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Flye on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=flye
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers flye

flye --pacbio-raw E.coli_PacBio_40x.fasta --out-dir out_pacbio --threads 12
flye --nano-raw Loman_E.coli_MAP006-1_2D_50x.fasta --out-dir out_nano --threads 12

fraggenescan

Link to section 'Introduction' of 'fraggenescan' Introduction

Fraggenescan is an application for finding (fragmented) genes in short reads. It can also be applied to predict prokaryotic genes in incomplete assemblies or complete genomes.

For more information, please check its website: https://biocontainers.pro/tools/fraggenescan and its home page on Github.

Link to section 'Versions' of 'fraggenescan' Versions

1.31

Link to section 'Commands' of 'fraggenescan' Commands

FragGeneScan
run_FragGeneScan.pl

Link to section 'Module' of 'fraggenescan' Module

You can load the modules by:

module load biocontainers
module load fraggenescan

Link to section 'Example job' of 'fraggenescan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fraggenescan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fraggenescan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fraggenescan

FragGeneScanRs -t 454_10 < example/NC_000913-454.fna > example/NC_000913-454.faa

fraggenescanrs

Link to section 'Introduction' of 'fraggenescanrs' Introduction

FragGeneScanRs is a better and faster Rust implementation of the FragGeneScan gene prediction model for short and error-prone reads. Its command line interface is backward compatible and adds extra features for more flexible usage. Compared to the original C implementation, shotgun metagenomic reads are processed up to 22 times faster using a single thread, with better scaling for multithreaded execution.

Home page: https://github.com/unipept/FragGeneScanRs

Link to section 'Versions' of 'fraggenescanrs' Versions

1.1.0

Link to section 'Commands' of 'fraggenescanrs' Commands

FragGeneScanRs

Link to section 'Module' of 'fraggenescanrs' Module

You can load the modules by:

module load biocontainers
module load fraggenescanrs

Link to section 'Example job' of 'fraggenescanrs' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run fraggenescanrs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fraggenescanrs
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fraggenescanrs

freebayes

Link to section 'Introduction' of 'freebayes' Introduction

Freebayes is a Bayesian genetic variant detector designed to find small polymorphisms, specifically SNPs (single-nucleotide polymorphisms), indels (insertions and deletions), MNPs (multi-nucleotide polymorphisms), and complex events (composite insertion and substitution events) smaller than the length of a short-read sequencing alignment.

For more information, please check its website: https://biocontainers.pro/tools/freebayes and its home page on Github.

Link to section 'Versions' of 'freebayes' Versions

1.3.5
1.3.6

Link to section 'Commands' of 'freebayes' Commands

freebayes
freebayes-parallel

Link to section 'Module' of 'freebayes' Module

You can load the modules by:

module load biocontainers
module load freebayes

Link to section 'Example job' of 'freebayes' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Freebayes on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=freebayes
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers freebayes

freebayes -f ref.fa aln.cram >var.vcf

freyja

Link to section 'Introduction' of 'freyja' Introduction

Freyja is a tool to recover relative lineage abundances from mixed SARS-CoV-2 samples from a sequencing dataset (BAM aligned to the Hu-1 reference). The method uses lineage-determining mutational "barcodes" derived from the UShER global phylogenetic tree as a basis set to solve the constrained (unit sum, non-negative) de-mixing problem.

Docker hub: https://hub.docker.com/r/staphb/freyja
Home page: https://github.com/andersen-lab/Freyja

Link to section 'Versions' of 'freyja' Versions

1.3.11

Link to section 'Commands' of 'freyja' Commands

freyja

Link to section 'Module' of 'freyja' Module

You can load the modules by:

module load biocontainers
module load freyja

Link to section 'Example job' of 'freyja' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run freyja on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=freyja
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers freyja

fseq

Link to section 'Introduction' of 'fseq' Introduction

Fseq is a feature density estimator for high-throughput sequence tags.

For more information, please check its home page: https://fureylab.web.unc.edu/software/fseq/.

Link to section 'Versions' of 'fseq' Versions

2.0.3

Link to section 'Commands' of 'fseq' Commands

fseq2

Link to section 'Module' of 'fseq' Module

You can load the modules by:

module load biocontainers
module load fseq

Link to section 'Example job' of 'fseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Fseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fseq

funannotate

Link to section 'Introduction' of 'funannotate' Introduction

Funannotate is a genome prediction, annotation, and comparison software package.

Docker hub: https://hub.docker.com/r/nextgenusfs/funannotate and its home page on Github.

Link to section 'Versions' of 'funannotate' Versions

1.8.10

Link to section 'Commands' of 'funannotate' Commands

funannotate

Link to section 'Module' of 'funannotate' Module

You can load the modules by:

module load biocontainers
module load funannotate

Link to section 'Example job' of 'funannotate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Funannotate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=funannotate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers funannotate

funannotate clean -i genome.fa -o genome_cleaned.fa
funannotate sort -i genome_cleaned.fa -o genome_cleaned_sorted.fa
funannotate predict -i genome_cleaned_sorted.fa -o predict_out --species "arabidopsis" --rna_bam  RNAseq.bam --cpus 12

fwdpy11

Link to section 'Introduction' of 'fwdpy11' Introduction

Fwdpy11 is a Python package for forward-time population genetic simulation.

Docker hub: https://hub.docker.com/r/molpopgen/fwdpy11
Home page: https://github.com/molpopgen/fwdpy11

Link to section 'Versions' of 'fwdpy11' Versions

0.18.1

Link to section 'Commands' of 'fwdpy11' Commands

python3
python

Link to section 'Module' of 'fwdpy11' Module

You can load the modules by:

module load biocontainers
module load fwdpy11

Link to section 'Interactive job' of 'fwdpy11' Interactive job

To run fwdpy11 interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers fwdpy11
(base) UserID@bell-a008:~ $ python
Python 3.8.10 (default, Mar 15 2022, 12:22:08) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import fwdpy11
>>> pop = fwdpy11.DiploidPopulation(100, 1000.0)
>>> print(f"N = {pop.N}, L = {pop.tables.genome_length}")

Link to section 'Batch job' of 'fwdpy11' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run fwdpy11 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=fwdpy11
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers fwdpy11

python script.py

gadma

Link to section 'Introduction' of 'gadma' Introduction

GADMA is a command-line tool. Basic pipeline presents a series of launches of the genetic algorithm followed by local search optimization and infers demographic history from the Allele Frequency Spectrum of multiple populations (up to three).

BioContainers: https://biocontainers.pro/tools/gadma
Home page: https://github.com/ctlab/GADMA

Link to section 'Versions' of 'gadma' Versions

2.0.0rc21

Link to section 'Commands' of 'gadma' Commands

gadma
python
python3

Link to section 'Module' of 'gadma' Module

You can load the modules by:

module load biocontainers
module load gadma

Link to section 'Interactive job' of 'gadma' Interactive job

To run GADMA interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers gadma
(base) UserID@bell-a008:~ $ python
Python 3.8.13 |  packaged by conda-forge |  (default, Mar 25 2022, 06:04:10)
[GCC 10.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> from gadma import *

Link to section 'Batch job' of 'gadma' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gadma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gadma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gadma

gadma -p params_file

gambit

Link to section 'Introduction' of 'gambit' Introduction

GAMBIT (Genomic Approximation Method for Bacterial Identification and Tracking) is a tool for rapid taxonomic identification of microbial pathogens.

Docker hub: https://hub.docker.com/r/staphb/gambit
Home page: https://github.com/jlumpe/gambit

Link to section 'Versions' of 'gambit' Versions

0.5.0

Link to section 'Commands' of 'gambit' Commands

gambit

Link to section 'Module' of 'gambit' Module

You can load the modules by:

module load biocontainers
module load gambit

Link to section 'Example job' of 'gambit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gambit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gambit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gambit

gambit -d database query -o results.csv *.fasta

gamma

Link to section 'Introduction' of 'gamma' Introduction

GAMMA (Gene Allele Mutation Microbial Assessment) is a command line tool that finds gene matches in microbial genomic data using protein coding (rather than nucleotide) identity, and then translates and annotates the match by providing the type (i.e., mutant, truncation, etc.) and a translated description (i.e., Y190S mutant, truncation at residue 110, etc.). Because microbial gene families often have multiple alleles and existing databases are rarely exhaustive, GAMMA is helpful in both identifying and explaining how unique alleles differ from their closest known matches.

Docker hub: https://hub.docker.com/r/staphb/gamma
Home page: https://github.com/rastanton/GAMMA

Link to section 'Versions' of 'gamma' Versions

Link to section 'Commands' of 'gamma' Commands

GAMMA-S.py
GAMMA.py

Link to section 'Module' of 'gamma' Module

You can load the modules by:

module load biocontainers
module load gamma

Link to section 'Example job' of 'gamma' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gamma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gamma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gamma

GAMMA.py DHQP1701672_complete_genome.fasta ResFinderDB_Combined_05-06-20.fsa GAMMA_Test

gangstr

Link to section 'Introduction' of 'gangstr' Introduction

GangSTR is a tool for genome-wide profiling tandem repeats from short reads. A key advantage of GangSTR over existing genome-wide TR tools (e.g. lobSTR or hipSTR) is that it can handle repeats that are longer than the read length. GangSTR takes aligned reads (BAM) and a set of repeats in the reference genome as input and outputs a VCF file containing genotypes for each locus.

BioContainers: https://biocontainers.pro/tools/gangstr
Home page: https://github.com/gymreklab/GangSTR

Link to section 'Versions' of 'gangstr' Versions

2.5.0

Link to section 'Commands' of 'gangstr' Commands

GangSTR

Link to section 'Module' of 'gangstr' Module

You can load the modules by:

module load biocontainers
module load gangstr

Link to section 'Example job' of 'gangstr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gangstr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gangstr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gangstr

gapfiller

Link to section 'Introduction' of 'gapfiller' Introduction

GapFiller is a seed-and-extend local assembler to fill the gap within paired reads. It can be used for both DNA and RNA and it has been tested on Illumina data. GapFiller can be used whenever a sequence is to be assembled starting from reads lying on its ends, provided a loose estimate of sequence length.

BioContainers: https://biocontainers.pro/tools/gapfiller
Home page: https://sourceforge.net/projects/gapfiller/

Link to section 'Versions' of 'gapfiller' Versions

2.1.2

Link to section 'Commands' of 'gapfiller' Commands

GapFiller

Link to section 'Module' of 'gapfiller' Module

You can load the modules by:

module load biocontainers
module load gapfiller

Link to section 'Example job' of 'gapfiller' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gapfiller on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gapfiller
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gapfiller

gatk

Link to section 'Introduction' of 'gatk' Introduction

GATK (Genome Analysis Toolkit) is a collection of command-line tools for analyzing high-throughput sequencing data with a primary focus on variant discovery.

For more information, please check its website: https://biocontainers.pro/tools/gatk and its home page: https://www.broadinstitute.org/gatk/.

Link to section 'Versions' of 'gatk' Versions

Link to section 'Commands' of 'gatk' Commands

gatk3

Link to section 'Module' of 'gatk' Module

You can load the modules by:

module load biocontainers
module load gatk

Link to section 'Example job' of 'gatk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run GATK on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=gatk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gatk

gatk3 -T HaplotypeCaller  \
    -nct 24  -R hg38.fa \
    -I 19P0126636WES.sorted.bam \
     -o 19P0126636WES.HC.vcf

gatk4

GATK (Genome Analysis Toolkit) is a collection of command-line tools for analyzing high-throughput sequencing data with a primary focus on variant discovery. Detailed usage can be found here: https://www.broadinstitute.org/gatk/.

Link to section 'Versions' of 'gatk4' Versions

4.2.0
4.2.5.0
4.2.6.1
4.3.0.0

Link to section 'Commands' of 'gatk4' Commands

gatk

Link to section 'Module' of 'gatk4' Module

You can load the modules by:

module load biocontainers
module load gatk4/4.2.5.0

Link to section 'Example job' of 'gatk4' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gatk4 our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=gatk4
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gatk4/4.2.5.0

gatk  --java-options "-Xmx12G -XX:ParallelGCThreads=24" HaplotypeCaller -R hg38.fa -I 19P0126636WES.sorted.bam  -O 19P0126636WES.HC.vcf --sample-name 19P0126636

gemma

Link to section 'Introduction' of 'gemma' Introduction

Gemma is a software toolkit for fast application of linear mixed models (LMMs) and related models to genome-wide association studies (GWAS) and other large-scale data sets.

For more information, please check its website: https://biocontainers.pro/tools/gemma and its home page on Github.

Link to section 'Versions' of 'gemma' Versions

0.98.3

Link to section 'Commands' of 'gemma' Commands

gemma

Link to section 'Module' of 'gemma' Module

You can load the modules by:

module load biocontainers
module load gemma

Link to section 'Example job' of 'gemma' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gemma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gemma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gemma

gemma -g ./example/mouse_hs1940.geno.txt.gz -p ./example/mouse_hs1940.pheno.txt \
    -gk -o mouse_hs1940

gemma -g ./example/mouse_hs1940.geno.txt.gz \
    -p ./example/mouse_hs1940.pheno.txt -n 1 -a ./example/mouse_hs1940.anno.txt \
    -k ./output/mouse_hs1940.cXX.txt -lmm -o mouse_hs1940_CD8_lmm

gemoma

Link to section 'Introduction' of 'gemoma' Introduction

Gene Model Mapper (GeMoMa) is a homology-based gene prediction program. GeMoMa uses the annotation of protein-coding genes in a reference genome to infer the annotation of protein-coding genes in a target genome. Thereby, GeMoMa utilizes amino acid sequence and intron position conservation. In addition, GeMoMa allows to incorporate RNA-seq evidence for splice site prediction.

BioContainers: https://biocontainers.pro/tools/gemoma
Home page: http://www.jstacs.de/index.php/GeMoMa

Link to section 'Versions' of 'gemoma' Versions

1.7.1

Link to section 'Commands' of 'gemoma' Commands

GeMoMa

Link to section 'Module' of 'gemoma' Module

You can load the modules by:

module load biocontainers
module load gemoma

Link to section 'Example job' of 'gemoma' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gemoma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gemoma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gemoma

genemark

Link to section 'Introduction' of 'genemark' Introduction

GeneMark-ES/ET/EP contains GeneMark-ES, GeneMark-ET and GeneMark-EP+ algorithms.

Link to section 'Versions' of 'genemark' Versions

4.68
4.69

Link to section 'Academic license' of 'genemark' Academic license

To use GeneMark, users need to download license files by yourself.

Go to the GeneMark web site: http://exon.gatech.edu/GeneMark/license_download.cgi. Check the boxes for GeneMark-ES/ET/EP ver 4.69_lic and LINUX 64 next to it, fill out the form, then click "I agree". In the next page, right click and copy the link addresses for 64 bit licenss. Paste the link addresses in the commands below:

cd $HOME
wget "replace with license URL"
zcat gm_key_64.gz > .gm_key

Link to section 'Module' of 'genemark' Module

You can load the modules by:

module load biocontainers
module load genemark/4.68

Link to section 'Example job' of 'genemark' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run GeneMark on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=genemark
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genemark/4.68  

gmes_petap.pl --ES  --cores 24 --sequence scaffolds.fasta

genemarks-2

Link to section 'Introduction' of 'genemarks-2' Introduction

GeneMarkS-2 combines GeneMark.hmm (prokaryotic) and GeneMark (prokaryotic) with a self-training procedure that determines parameters of the models of both GeneMark.hmm and GeneMark.

Home page: http://opal.biology.gatech.edu/GeneMark/

Link to section 'Versions' of 'genemarks-2' Versions

1.14_1.25

Link to section 'Commands' of 'genemarks-2' Commands

gms2.pl
biogem
compp
gmhmmp2

Link to section 'Module' of 'genemarks-2' Module

You can load the modules by:

module load biocontainers
module load genemarks-2

Link to section 'Example job' of 'genemarks-2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run genemarks-2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genemarks-2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genemarks-2

genmap

Link to section 'Introduction' of 'genmap' Introduction

GenMap: Ultra-fast Computation of Genome Mappability.

BioContainers: https://biocontainers.pro/tools/genmap
Home page: https://github.com/cpockrandt/genmap

Link to section 'Versions' of 'genmap' Versions

1.3.0

Link to section 'Commands' of 'genmap' Commands

genmap

Link to section 'Module' of 'genmap' Module

You can load the modules by:

module load biocontainers
module load genmap

Link to section 'Example job' of 'genmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run genmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genmap

export TMPDIR=$PWD/tmp
genmap index -F ~/.local/share/genomes/hg38/hg38.fa  -I hg38_index
genmap map -K 64 -E 2 -I hg38_index -O map_output_hg38 -t -w -bg

genomedata

Link to section 'Introduction' of 'genomedata' Introduction

Genomedata is a format for efficient storage of multiple tracks of numeric data anchored to a genome. The format allows fast random access to hundreds of gigabytes of data, while retaining a small disk space footprint.

BioContainers: https://biocontainers.pro/tools/genomedata
Home page: http://pmgenomics.ca/hoffmanlab/proj/genomedata/

Link to section 'Versions' of 'genomedata' Versions

1.5.0

Link to section 'Module' of 'genomedata' Module

You can load the modules by:

module load biocontainers
module load genomedata

Link to section 'Example job' of 'genomedata' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run genomedata on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genomedata
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genomedata

genomepy

Link to section 'Introduction' of 'genomepy' Introduction

Genomepy is designed to provide a simple and straightforward way to download and use genomic data.

For more information, please check its website: https://biocontainers.pro/tools/genomepy and its home page on Github.

Link to section 'Versions' of 'genomepy' Versions

0.12.0
0.14.0

Link to section 'Commands' of 'genomepy' Commands

genomepy

Link to section 'Module' of 'genomepy' Module

You can load the modules by:

module load biocontainers
module load genomepy

Link to section 'Example job' of 'genomepy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Genomepy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genomepy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genomepy

genomescope2

Link to section 'Introduction' of 'genomescope2' Introduction

Genomescope2: Reference-free profiling of polyploid genomes.

For more information, please check its website: https://biocontainers.pro/tools/genomescope2 and its home page on Github.

Link to section 'Versions' of 'genomescope2' Versions

Link to section 'Commands' of 'genomescope2' Commands

genomescope2

Link to section 'Module' of 'genomescope2' Module

You can load the modules by:

module load biocontainers
module load genomescope2

Link to section 'Example job' of 'genomescope2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Genomescope2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genomescope2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genomescope2

wget https://raw.githubusercontent.com/schatzlab/genomescope/master/analysis/real_data/ara_F1_21.hist

genomescope2 -i ara_F1_21.hist -o output -k 21

genomicconsensus

Link to section 'Introduction' of 'genomicconsensus' Introduction

Genomicconsensus is the current PacBio consensus and variant calling suite.

For more information, please check its website: https://biocontainers.pro/tools/genomicconsensus.

Link to section 'Versions' of 'genomicconsensus' Versions

2.3.3

Link to section 'Commands' of 'genomicconsensus' Commands

quiver
arrow
variantCaller

Link to section 'Module' of 'genomicconsensus' Module

You can load the modules by:

module load biocontainers
module load genomicconsensus

Link to section 'Example job' of 'genomicconsensus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Genomicconsensus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genomicconsensus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genomicconsensus

quiver -j12 out.aligned_subreads.bam \ 
    -r All4mer.V2.01_Insert-changed.fa  \
    -o consensus.fasta -o consensus.fastq

genrich

Link to section 'Introduction' of 'genrich' Introduction

Genrich is a peak-caller for genomic enrichment assays (e.g. ChIP-seq, ATAC-seq). It analyzes alignment files generated following the assay and produces a file detailing peaks of significant enrichment.

For more information, please check its website: https://biocontainers.pro/tools/genrich and its home page on Github.

Link to section 'Versions' of 'genrich' Versions

0.6.1

Link to section 'Commands' of 'genrich' Commands

Genrich

Link to section 'Module' of 'genrich' Module

You can load the modules by:

module load biocontainers
module load genrich

Link to section 'Example job' of 'genrich' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Genrich on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=genrich
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers genrich

Genrich  -t sample.bam  -o sample.narrowPeak  -v

gfaffix

Link to section 'Introduction' of 'gfaffix' Introduction

GFAffix identifies walk-preserving shared affixes in variation graphs and collapses them into a non-redundant graph structure.

BioContainers: https://biocontainers.pro/tools/gfaffix
Home page: https://github.com/marschall-lab/GFAffix

Link to section 'Versions' of 'gfaffix' Versions

0.1.4

Link to section 'Commands' of 'gfaffix' Commands

gfaffix

Link to section 'Module' of 'gfaffix' Module

You can load the modules by:

module load biocontainers
module load gfaffix

Link to section 'Example job' of 'gfaffix' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gfaffix on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gfaffix
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gfaffix

gfastats

Link to section 'Introduction' of 'gfastats' Introduction

gfastats is a single fast and exhaustive tool for summary statistics and simultaneous fa (fasta, fastq, gfa [.gz]) genome assembly file manipulation. gfastats also allows seamless fasta<>fastq<>gfa[.gz] conversion. It has been tested in genomes even >100Gbp.

BioContainers: https://biocontainers.pro/tools/gfastats
Home page: https://github.com/vgl-hub/gfastats

Link to section 'Versions' of 'gfastats' Versions

1.2.3

Link to section 'Commands' of 'gfastats' Commands

gfastats

Link to section 'Module' of 'gfastats' Module

You can load the modules by:

module load biocontainers
module load gfastats

Link to section 'Example job' of 'gfastats' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gfastats on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gfastats
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gfastats

gfastats input.fasta -o gfa

gfatools

Link to section 'Introduction' of 'gfatools' Introduction

gfatools is a set of tools for manipulating sequence graphs in the GFA or the rGFA format. It has implemented parsing, subgraph and conversion to FASTA/BED.

BioContainers: https://biocontainers.pro/tools/gfatools
Home page: https://github.com/lh3/gfatools

Link to section 'Versions' of 'gfatools' Versions

Link to section 'Commands' of 'gfatools' Commands

gfatools

Link to section 'Module' of 'gfatools' Module

You can load the modules by:

module load biocontainers
module load gfatools

Link to section 'Example job' of 'gfatools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gfatools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gfatools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gfatools

# Extract a subgraph
gfatools view -l MTh4502 -r 1 test/MT.gfa > sub.gfa

# Convert GFA to segment FASTA
gfatools gfa2fa test/MT.gfa > MT-seg.fa

# Convert rGFA to stable FASTA or BED
gfatools gfa2fa -s test/MT.gfa > MT.fa
gfatools gfa2bed -m test/MT.gfa > MT.bed

gffcompare

Link to section 'Introduction' of 'gffcompare' Introduction

Gffcompare is used to compare, merge, annotate and estimate accuracy of one or more GFF files.

For more information, please check its website: https://biocontainers.pro/tools/gffcompare and its home page: https://ccb.jhu.edu/software/stringtie/gffcompare.shtml.

Link to section 'Versions' of 'gffcompare' Versions

0.11.2

Link to section 'Commands' of 'gffcompare' Commands

gffcompare

Link to section 'Module' of 'gffcompare' Module

You can load the modules by:

module load biocontainers
module load gffcompare

Link to section 'Example job' of 'gffcompare' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gffcompare on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gffcompare
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gffcompare

gffcompare -r annotation.gff transcripts.gtf

gffread

Link to section 'Introduction' of 'gffread' Introduction

Gffread is used to validate, filter, convert and perform various other operations on GFF files.

For more information, please check its website: https://biocontainers.pro/tools/gffread and its home page: http://ccb.jhu.edu/software/stringtie/gff.shtml.

Link to section 'Versions' of 'gffread' Versions

0.12.7

Link to section 'Commands' of 'gffread' Commands

gffread

Link to section 'Module' of 'gffread' Module

You can load the modules by:

module load biocontainers
module load gffread

Link to section 'Example job' of 'gffread' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gffread on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gffread
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gffread

gffread -E annotation.gff -o ann_simple.gff

gffread annotation.gff -T -o annotation.gtf

gffread -w transcripts.fa -g genome.fa annotation.gff

gffutils

Link to section 'Introduction' of 'gffutils' Introduction

gffutils is a Python package for working with and manipulating the GFF and GTF format files typically used for genomic annotations.

BioContainers: https://biocontainers.pro/tools/gffutils
Home page: https://github.com/daler/gffutils

Link to section 'Versions' of 'gffutils' Versions

0.11.1

Link to section 'Commands' of 'gffutils' Commands

python
python3

Link to section 'Module' of 'gffutils' Module

You can load the modules by:

module load biocontainers
module load gffutils

Link to section 'Example job' of 'gffutils' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gffutils on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gffutils
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gffutils

gimmemotifs

Link to section 'Introduction' of 'gimmemotifs' Introduction

GimmeMotifs is a suite of motif tools, including a motif prediction pipeline for ChIP-seq experiments.

BioContainers: https://biocontainers.pro/tools/gimmemotifs
Home page: https://github.com/vanheeringen-lab/gimmemotifs

Link to section 'Versions' of 'gimmemotifs' Versions

0.17.1

Link to section 'Commands' of 'gimmemotifs' Commands

gimme -

Link to section 'Module' of 'gimmemotifs' Module

You can load the modules by:

module load biocontainers
module load gimmemotifs

Link to section 'Example job' of 'gimmemotifs' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run gimmemotifs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gimmemotifs
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gimmemotifs

gimme motifs ENCFF407IVS.bed ENCFF407IVS_motifs \
    -g ~/.local/share/genomes/hg38/hg38.fa --denovo

glimmer

Link to section 'Introduction' of 'glimmer' Introduction

Glimmer is a system for finding genes in microbial DNA, especially the genomes of bacteria, archaea, and viruses.

For more information, please check its website: https://biocontainers.pro/tools/glimmer and its home page: http://ccb.jhu.edu/software/glimmer/index.shtml.

Link to section 'Versions' of 'glimmer' Versions

3.02

Link to section 'Module' of 'glimmer' Module

You can load the modules by:

module load biocontainers
module load glimmer

Link to section 'Example job' of 'glimmer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Glimmer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=glimmer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers glimmer

long-orfs -n -t 1.15 scaffolds.fasta run1.longorfs
extract -t scaffolds.fasta run1.longorfs > run1.train
build-icm -r run1.icm < run1.train
glimmer3 scaffolds.fasta run1.icm cm

glimmerhmm

Link to section 'Introduction' of 'glimmerhmm' Introduction

Glimmerhmm is a new gene finder based on a Generalized Hidden Markov Model (GHMM).

For more information, please check its website: https://biocontainers.pro/tools/glimmerhmm and its home page: https://ccb.jhu.edu/software/glimmerhmm/.

Link to section 'Versions' of 'glimmerhmm' Versions

3.0.4

Link to section 'Commands' of 'glimmerhmm' Commands

glimmerhmm
glimmhmm.pl
trainGlimmerHMM

Link to section 'Module' of 'glimmerhmm' Module

You can load the modules by:

module load biocontainers
module load glimmerhmm

Link to section 'Example job' of 'glimmerhmm' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Glimmerhmm on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=glimmerhmm
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers glimmerhmm

trainGlimmerHMM Asperg.fasta Asperg.cds -d Asperg
glimmerhmm Asperg.fasta -d Asperg -o Asperg_glimmerhmm_out

glnexus

Link to section 'Introduction' of 'glnexus' Introduction

Glnexus: Scalable gVCF merging and joint variant calling for population sequencing projects.

BioContainers: https://biocontainers.pro/tools/glnexus
Home page: https://github.com/dnanexus-rnd/GLnexus

Link to section 'Versions' of 'glnexus' Versions

1.4.1

Link to section 'Commands' of 'glnexus' Commands

glnexus_cli

Link to section 'Module' of 'glnexus' Module

You can load the modules by:

module load biocontainers
module load glnexus

Link to section 'Example job' of 'glnexus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run glnexus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=glnexus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers glnexus

glnexus_cli --config DeepVariant \
    --bed ALDH2.bed \
    dv_1000G_ALDH2_gvcf/*.g.vcf.gz \
    > dv_1000G_ALDH2.bcf

gmap

Link to section 'Introduction' of 'gmap' Introduction

Gmap is a genomic mapping and alignment program for mRNA and EST sequences.

For more information, please check its website: https://biocontainers.pro/tools/gmap and its home page: http://research-pub.gene.com/gmap/.

Link to section 'Versions' of 'gmap' Versions

2021.05.27
2021.08.25

Link to section 'Module' of 'gmap' Module

You can load the modules by:

module load biocontainers
module load gmap

Link to section 'Example job' of 'gmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=gmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gmap

gmap_build -d Cmm -D Cmm genome.fasta
gmap -d Cmm -t 4 -D ./Cmm  cdna.fasta > gmap_out.txt

gmap_build -d GRCh38 -D GRCh38 Homo_sapiens.GRCh38.dna.primary_assembly.fa
gsnap -d GRCh38 -D ./GRCh38 --nthreads=4  SRR16956239_1.fastq SRR16956239_2.fastq > gsnap_out.txt

goatools

Goatools is a python library for gene ontology analyses. Detailed information about its usage can be found here: https://github.com/tanghaibao/goatools

Link to section 'Versions' of 'goatools' Versions

1.1.12
1.2.3

Link to section 'Module' of 'goatools' Module

You can load the modules by:

module load biocontainers  
module load goatools/1.1.12

Link to section 'Interactive job' of 'goatools' Interactive job

To run goatools interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers goatools/1.1.12
(base) UserID@bell-a008:~ $ python
Python 3.8.10 (default, Nov 26 2021, 20:14:08)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> from goatools.base import download_go_basic_obo
>>> obo_fname = download_go_basic_obo()

Link to section 'Batch job' of 'goatools' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=goatools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers goatools/1.1.12

python script.py

find_enrichment.py --pval=0.05 --indent data/study data/population data/association

go_plot.py --go_file=tests/data/go_plot/go_heartjogging6.txt -r -o heartjogging6_r1.png

graphlan

Link to section 'Introduction' of 'graphlan' Introduction

Graphlan is a software tool for producing high-quality circular representations of taxonomic and phylogenetic trees.

For more information, please check its website: https://biocontainers.pro/tools/graphlan and its home page: https://huttenhower.sph.harvard.edu/graphlan/.

Link to section 'Versions' of 'graphlan' Versions

1.1.3

Link to section 'Commands' of 'graphlan' Commands

graphlan.py
graphlan_annotate.py

Link to section 'Module' of 'graphlan' Module

You can load the modules by:

module load biocontainers
module load graphlan

Link to section 'Example job' of 'graphlan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Graphlan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=graphlan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers graphlan

graphlan_annotate.py hmptree.xml hmptree.annot.xml --annot annot.txt

graphlan.py hmptree.annot.xml hmptree.png --dpi 150 --size 14

graphmap

Link to section 'Introduction' of 'graphmap' Introduction

Graphmap is a novel mapper targeted at aligning long, error-prone third-generation sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/graphmap and its home page on Github.

Link to section 'Versions' of 'graphmap' Versions

0.6.3

Link to section 'Commands' of 'graphmap' Commands

graphmap2

Link to section 'Module' of 'graphmap' Module

You can load the modules by:

module load biocontainers
module load graphmap

Link to section 'Example job' of 'graphmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Graphmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=graphmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers graphmap

gridss

Link to section 'Introduction' of 'gridss' Introduction

Gridss is a module software suite containing tools useful for the detection of genomic rearrangements.

Docker hub: https://hub.docker.com/r/gridss/gridss and its home page on Github.

Link to section 'Versions' of 'gridss' Versions

2.13.2

Link to section 'Module' of 'gridss' Module

You can load the modules by:

module load biocontainers
module load gridss

Link to section 'Example job' of 'gridss' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gridss on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gridss
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gridss

gseapy

Link to section 'Introduction' of 'gseapy' Introduction

Gseapy is a python wrapper for GESA and Enrichr.

For more information, please check its website: https://biocontainers.pro/tools/gseapy and its home page: https://gseapy.readthedocs.io/en/latest/introduction.html.

Link to section 'Versions' of 'gseapy' Versions

0.10.8

Link to section 'Commands' of 'gseapy' Commands

gseapy
python
python3

Link to section 'Module' of 'gseapy' Module

You can load the modules by:

module load biocontainers
module load gseapy

Link to section 'Example job' of 'gseapy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gseapy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gseapy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gseapy

gseapy ssgsea -d ./data/testSet_rand1200.gct \
            -g data/temp.gmt \
            -o test/ssgsea_report2  \
            -p 4 --no-plot --no-scale
gseapy replot -i data -o test/replot_test

gtdbtk

Link to section 'Introduction' of 'gtdbtk' Introduction

GTDB-Tk is a software toolkit for assigning objective taxonomic classifications to bacterial and archaeal genomes based on the Genome Database Taxonomy GTDB. It is designed to work with recent advances that allow hundreds or thousands of metagenome-assembled genomes (MAGs) to be obtained directly from environmental samples. It can also be applied to isolate and single-cell genomes.

GTDB-Tk reference data (R202) has been downloaded for users.

Link to section 'Versions' of 'gtdbtk' Versions

1.7.0
2.1.0

Link to section 'Commands' of 'gtdbtk' Commands

gtdbtk

Link to section 'Module' of 'gtdbtk' Module

module load biocontainers module load gtdbtk/1.7.0

Link to section 'Example job' of 'gtdbtk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run GTDB-Tk our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=gtdbtk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gtdbtk/1.7.0

gtdbtk identify --genome_dir genomes --out_dir identify --extension gz --cpus 8
gtdbtk align --identify_dir identify --out_dir align --cpus 8
gtdbtk classify --genome_dir genomes --align_dir align --out_dir classify --extension gz --cpus 8

gubbins

Link to section 'Introduction' of 'gubbins' Introduction

Gubbins is an algorithm that iteratively identifies loci containing elevated densities of base substitutions while concurrently constructing a phylogeny based on the putative point mutations outside of these regions.

For more information, please check its website: https://biocontainers.pro/tools/gubbins and its home page on Github.

Link to section 'Versions' of 'gubbins' Versions

3.2.0
3.3

Link to section 'Commands' of 'gubbins' Commands

extract_gubbins_clade.py
generate_ska_alignment.py
gubbins_alignment_checker.py
mask_gubbins_aln.py
run_gubbins.py
sumlabels.py
sumtrees.py

Link to section 'Module' of 'gubbins' Module

You can load the modules by:

module load biocontainers
module load gubbins

Link to section 'Example job' of 'gubbins' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Gubbins on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=gubbins
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers gubbins

run_gubbins.py --prefix ST239 ST239.aln

guppy

Link to section 'Introduction' of 'guppy' Introduction

Guppy is a data processing toolkit that contains the Oxford Nanopore Technologies’ basecalling algorithms, and several bioinformatic post-processing features.

Docker hub: https://hub.docker.com/r/genomicpariscentre/guppy and its home page: https://community.nanoporetech.com.

Link to section 'Versions' of 'guppy' Versions

6.0.1

Link to section 'Commands' of 'guppy' Commands

guppy_aligner
guppy_barcoder
guppy_basecall_server
guppy_basecaller
guppy_basecaller_duplex
guppy_basecaller_supervisor
guppy_basecall_client

Link to section 'Module' of 'guppy' Module

You can load the modules by:

module load biocontainers
module load guppy

Link to section 'Example job' of 'guppy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Guppy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=guppy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers guppy

guppy_basecaller --compress_fastq -i data/fast5_tiny/ \
    -s basecall_tiny/ --cpu_threads_per_caller 12 \
    --num_callers 1 -c dna_r9.4.1_450bps_hac.cfg

hail

Link to section 'Introduction' of 'hail' Introduction

Hail is an open-source, general-purpose, Python-based data analysis tool with additional data types and methods for working with genomic data.

Docker hub: https://hub.docker.com/r/hailgenetics/hail
Home page: https://github.com/hail-is/hail

Link to section 'Versions' of 'hail' Versions

0.2.94
0.2.98

Link to section 'Commands' of 'hail' Commands

python3

Link to section 'Module' of 'hail' Module

You can load the modules by:

module load biocontainers
module load hail

Link to section 'Interactive job' of 'hail' Interactive job

To run Hail interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers hail
(base) UserID@bell-a008:~ $ python3
Python 3.7.13 (default, Apr 24 2022, 01:05:22)  
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import hail as hl
>>>  print(hl.citation())
Hail Team. Hail 0.2.94-f0b38d6c436f. https://github.com/hail-is/hail/commit/f0b38d6c436f.

Link to section 'Batch job' of 'hail' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run hail on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hail
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hail
python3 script.py

hap.py

Link to section 'Introduction' of 'hap.py' Introduction

Hap.py is a tool to compare diploid genotypes at haplotype level.

Docker hub: https://hub.docker.com/r/pkrusche/hap.py
Home page: https://github.com/Illumina/hap.py

Link to section 'Versions' of 'hap.py' Versions

0.3.9

Link to section 'Module' of 'hap.py' Module

You can load the modules by:

module load biocontainers
module load hap.py

Link to section 'Example job' of 'hap.py' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run hap.py on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hap.py
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hap.py

hap.py  \
  example/happy/PG_NA12878_chr21.vcf.gz \
  example/happy/NA12878_chr21.vcf.gz \
  -f example/happy/PG_Conf_chr21.bed.gz \
  -r example/chr21.fa \
  -o test

helen

Link to section 'Introduction' of 'helen' Introduction

HELEN is a multi-task RNN polisher which operates on images produced by MarginPolish.

Docker hub: https://hub.docker.com/r/kishwars/helen
Home page: https://github.com/kishwarshafin/helen

Link to section 'Versions' of 'helen' Versions

Link to section 'Commands' of 'helen' Commands

helen

Link to section 'Module' of 'helen' Module

You can load the modules by:

module load biocontainers
module load helen

Link to section 'Example job' of 'helen' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run helen on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 32
#SBATCH --job-name=helen
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers helen

helen polish \
    --image_dir mp_output \
    --model_path "helen_modles/HELEN_r941_guppy344_microbial.pkl" \
    --threads 32 \
    --output_dir "helen_output/" \
    --output_prefix Staph_Aur_draft_helen

hic-pro

Link to section 'Introduction' of 'hic-pro' Introduction

Hicpro is an optimized and flexible pipeline for Hi-C data processing.

Docker hub: https://hub.docker.com/r/nservant/hicpro
Home page: https://github.com/nservant/HiC-Pro

Link to section 'Versions' of 'hic-pro' Versions

3.0.0
3.1.0

Link to section 'Module' of 'hic-pro' Module

You can load the modules by:

module load biocontainers
module load hic-pro

Link to section 'Example job' of 'hic-pro' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run hic-pro on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hic-pro
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hic-pro

hicexplorer

Link to section 'Introduction' of 'hicexplorer' Introduction

Hicexplorer is a set of tools to process, normalize and visualize Hi-C data.

For more information, please check its website: https://biocontainers.pro/tools/hicexplorer and its home page: https://hicexplorer.readthedocs.io/en/latest/#.

Link to section 'Versions' of 'hicexplorer' Versions

3.7.2

Link to section 'Module' of 'hicexplorer' Module

You can load the modules by:

module load biocontainers
module load hicexplorer

Link to section 'Example job' of 'hicexplorer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Hicexplorer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hicexplorer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hicexplorer

hifiasm

Link to section 'Introduction' of 'hifiasm' Introduction

Hifiasm is a fast haplotype-resolved de novo assembler for PacBio HiFi reads.

For more information, please check its website: https://biocontainers.pro/tools/hifiasm and its home page on Github.

Link to section 'Versions' of 'hifiasm' Versions

0.16.0
0.18.5

Link to section 'Commands' of 'hifiasm' Commands

hifiasm

Link to section 'Module' of 'hifiasm' Module

You can load the modules by:

module load biocontainers
module load hifiasm

Link to section 'Example job' of 'hifiasm' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Hifiasm on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hifiasm
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hifiasm

hisat2

Link to section 'Introduction' of 'hisat2' Introduction

HISAT2 is a fast and sensitive alignment program for mapping next-generation sequencing reads (both DNA and RNA) to a population of human genomes as well as to a single reference genome.

For more information, please check its website: https://biocontainers.pro/tools/hisat2.

Link to section 'Versions' of 'hisat2' Versions

2.2.1

Link to section 'Module' of 'hisat2' Module

You can load the modules by:

module load biocontainers
module load hisat2

Link to section 'Example job' of 'hisat2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run HISAT2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hisat2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hisat2

hisat2-build genome.fa genome

# for single-end FASTA reads DNA alignment
hisat2 -f -x genome -U reads.fa -S output.sam --no-spliced-alignment

# for paired-end FASTQ reads alignment
hisat2 -x genome -1 reads_1.fq -2 read2_2.fq -S output.sam

hmmer

Link to section 'Introduction' of 'hmmer' Introduction

Hmmer is used for searching sequence databases for sequence homologs, and for making sequence alignments.

For more information, please check its website: https://biocontainers.pro/tools/hmmer and its home page: http://hmmer.org.

Link to section 'Versions' of 'hmmer' Versions

3.3.2

Link to section 'Module' of 'hmmer' Module

You can load the modules by:

module load biocontainers
module load hmmer

Link to section 'Example job' of 'hmmer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Hmmer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hmmer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hmmer

hmmsearch Nramp.hmm protein.fa > out

homer

HOMER (Hypergeometric Optimization of Motif EnRichment) is a suite of tools for Motif Discovery and next-gen sequencing analysis. Details about its usage can be found in HOMER website.

Link to section 'Versions' of 'homer' Versions

4.11

Link to section 'Database' of 'homer' Database

Selected database have been downloaded for users.

ORGANISMS: yeast, worm, mouse, arabidopsis, zebrafish, rat, human and fly
PROMOTERS: yeast, worm, mouse, arabidopsis, zebrafish, rat, human and fly
GENOMES: hg19, hg38, mm10, ce11, dm6, rn6, danRer11, tair10, and sacCer3

Link to section 'Module' of 'homer' Module

You can load the modules by:

module load biocontainers
module load homer/4.11

Link to section 'Example job' of 'homer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run HOMER on our cluster:

#!/bin/bash
#SBATCH -A myallocation	# Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=homer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers homer/4.11

configureHomer.pl -list   ## Check the installed database. 
findMotifs.pl mouse_geneid.txt mouse motif_out_mouse
findMotifs.pl geneid.txt human motif_out

how_are_we_stranded_here

Link to section 'Introduction' of 'how_are_we_stranded_here' Introduction

How_are_we_stranded_here is a python package for testing strandedness of RNA-Seq fastq files.

For more information, please check its website: https://biocontainers.pro/tools/how_are_we_stranded_here and its home page on Github.

Link to section 'Versions' of 'how_are_we_stranded_here' Versions

1.0.1

Link to section 'Commands' of 'how_are_we_stranded_here' Commands

check_strandedness

Link to section 'Module' of 'how_are_we_stranded_here' Module

You can load the modules by:

module load biocontainers
module load how_are_we_stranded_here

Link to section 'Example job' of 'how_are_we_stranded_here' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run How_are_we_stranded_here on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=how_are_we_stranded_here
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers how_are_we_stranded_here

check_strandedness --gtf Homo_sapiens.GRCh38.105.gtf \ 
    --transcripts Homo_sapiens.GRCh38.cds.all.fa \
    --reads_1 seq_1.fastq  --reads_2 seq_2.fastq

htseq

Link to section 'Introduction' of 'htseq' Introduction

HTSeq is a Python library to facilitate processing and analysis of data from high-throughput sequencing (HTS) experiments.

For more information, please check its website: https://biocontainers.pro/tools/htseq and its home page on Github.

Link to section 'Versions' of 'htseq' Versions

0.13.5
1.99.2
2.0.1
2.0.2
2.0.2-py310

Link to section 'Commands' of 'htseq' Commands

htseq-count
htseq-count-barcodes
htseq-qa
python
python3

Link to section 'Module' of 'htseq' Module

You can load the modules by:

module load biocontainers
module load htseq

Link to section 'Example job' of 'htseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run HTSeq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=htseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers htseq

htseq-count input.bam ref.gtf > test.out

htslib

Link to section 'Introduction' of 'htslib' Introduction

Htslib is a C library for high-throughput sequencing data formats.

For more information, please check its website: https://biocontainers.pro/tools/htslib and its home page on Github.

Link to section 'Versions' of 'htslib' Versions

1.14
1.15
1.16

Link to section 'Commands' of 'htslib' Commands

bgzip
htsfile
tabix

Link to section 'Module' of 'htslib' Module

You can load the modules by:

module load biocontainers
module load htslib

Link to section 'Example job' of 'htslib' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Htslib on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=htslib
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers htslib

tabix sorted.gff.gz chr1:10,000,000-20,000,000

htstream

Link to section 'Introduction' of 'htstream' Introduction

Htstream is a quality control and processing pipeline for High Throughput Sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/htstream and its home page on Github.

Link to section 'Versions' of 'htstream' Versions

1.3.3

Link to section 'Module' of 'htstream' Module

You can load the modules by:

module load biocontainers
module load htstream

Link to section 'Example job' of 'htstream' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Htstream on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=htstream
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers htstream

humann

Link to section 'Introduction' of 'humann' Introduction

HUMAnN 3.0 is the next iteration of HUMAnN, the HMP Unified Metabolic Analysis Network. HUMAnN is a method for efficiently and accurately profiling the abundance of microbial metabolic pathways and other molecular functions from metagenomic or metatranscriptomic sequencing data.

For more information please check its website: https://huttenhower.sph.harvard.edu/humann/

Link to section 'Versions' of 'humann' Versions

3.0.0
3.6

Link to section 'Database ' of 'humann' Database

Full ChocoPhlAn, UniRef90, EC-filtered UniRef90, UniRef50, EC-filtered UniRef50, and utility_mapping databases have been downloaded for users.

Link to section 'Module' of 'humann' Module

You can load the modules by:

module load biocontainers
module load humann/3.0.0

Link to section 'Example job' of 'humann' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run HUMAnN3 on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=humann
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers humann/3.0.0 
# Check the database and config by: 
humann_config --print

humann --threads 24 --input examples/demo.fastq --output demo_output --metaphlan-options "--bowtie2db /depot/itap/datasets/metaphlan"

hyphy

Link to section 'Introduction' of 'hyphy' Introduction

Hyphy is an open-source software package for the analysis of genetic sequences using techniques in phylogenetics, molecular evolution, and machine learning.

For more information, please check its website: https://biocontainers.pro/tools/hyphy and its home page on Github.

Link to section 'Versions' of 'hyphy' Versions

2.5.36

Link to section 'Commands' of 'hyphy' Commands

hyphy

Link to section 'Module' of 'hyphy' Module

You can load the modules by:

module load biocontainers
module load hyphy

Link to section 'Example job' of 'hyphy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Hyphy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=hyphy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers hyphy

idba

Link to section 'Introduction' of 'idba' Introduction

Idba is a practical iterative De Bruijn Graph De Novo Assembler for sequence assembly in bioinformatics.

For more information, please check its website: https://biocontainers.pro/tools/idba and its home page: https://i.cs.hku.hk/~alse/hkubrg/projects/idba/index.html.

Link to section 'Versions' of 'idba' Versions

1.1.3

Link to section 'Module' of 'idba' Module

You can load the modules by:

module load biocontainers
module load idba

Link to section 'Example job' of 'idba' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Idba on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=idba
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers idba

fq2fa --paired --filter SRR1977249.abundtrim.subset.pe.fq SRR1977249.abundtrim.subset.pe.fa
idba_ud  -r SRR1977249.abundtrim.subset.pe.fa -o output

igv

Link to section 'Introduction' of 'igv' Introduction

IGV (Integrative Genomics Viewer) is a high-performance, easy-to-use, interactive tool for the visual exploration of genomic data.

For more information, please check its home page: https://software.broadinstitute.org/software/igv/home.

Link to section 'Versions' of 'igv' Versions

2.11.9
2.12.3

Link to section 'Commands' of 'igv' Commands

igv_hidpi.sh
igv.sh

Link to section 'Module' of 'igv' Module

You can load the modules by:

module load biocontainers
module load igv

Link to section 'Interactive job' of 'igv' Interactive job

Since IGV requires GUI, it is recommended to run it within ThinLinc:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
 salloc: Granted job allocation 12345869
 salloc: Waiting for resource configuration
 salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module --force purge
(base) UserID@bell-a008:~ $ ml biocontainers igv
(base) UserID@bell-a008:~ $ igv.sh

impute2

Link to section 'Introduction' of 'impute2' Introduction

Impute2 is a genotype imputation and haplotype phasing program.

For more information, please check its website: https://biocontainers.pro/tools/impute2 and its home page: https://mathgen.stats.ox.ac.uk/impute/impute_v2.html#home.

Link to section 'Versions' of 'impute2' Versions

2.3.2

Link to section 'Commands' of 'impute2' Commands

impute2

Link to section 'Module' of 'impute2' Module

You can load the modules by:

module load biocontainers
module load impute2

Link to section 'Example job' of 'impute2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Impute2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=impute2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers impute2

impute2 \
    -m Example/example.chr22.map \
    -h Example/example.chr22.1kG.haps \
    -l Example/example.chr22.1kG.legend \
    -g Example/example.chr22.study.gens \
    -strand_g Example/example.chr22.study.strand \
    -int 20.4e6 20.5e6 \
    -Ne 20000 \
    -o example.chr22.one.phased.impute2

infernal

Link to section 'Introduction' of 'infernal' Introduction

Infernal ("INFERence of RNA ALignment") is for searching DNA sequence databases for RNA structure and sequence similarities. It is an implementation of a special case of profile stochastic context-free grammars called covariance models (CMs). A CM is like a sequence profile, but it scores a combination of sequence consensus and RNA secondary structure consensus, so in many cases, it is more capable of identifying RNA homologs that conserve their secondary structure more than their primary sequence. For more information, please check: BioContainers: https://biocontainers.pro/tools/infernal
Home page: http://eddylab.org/infernal/

Link to section 'Versions' of 'infernal' Versions

1.1.4

Link to section 'Module' of 'infernal' Module

You can load the modules by:

module load biocontainers
module load infernal

Link to section 'Example job' of 'infernal' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run infernal on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=infernal
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers infernal

instrain

Link to section 'Introduction' of 'instrain' Introduction

Instrain is a python program for analysis of co-occurring genome populations from metagenomes that allows highly accurate genome comparisons, analysis of coverage, microdiversity, and linkage, and sensitive SNP detection with gene localization and synonymous non-synonymous identification.

For more information, please check its website: https://biocontainers.pro/tools/instrain and its home page on Github.

Link to section 'Versions' of 'instrain' Versions

1.5.7
1.6.3

Link to section 'Commands' of 'instrain' Commands

inStrain

Link to section 'Module' of 'instrain' Module

You can load the modules by:

module load biocontainers
module load instrain

Link to section 'Example job' of 'instrain' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Instrain on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=instrain
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers instrain

intarna

Link to section 'Introduction' of 'intarna' Introduction

Intarna is a general and fast approach to the prediction of RNA-RNA interactions incorporating both the accessibility of interacting sites as well as the existence of a user-definable seed interaction.

For more information, please check its website: https://biocontainers.pro/tools/intarna and its home page on Github.

Link to section 'Versions' of 'intarna' Versions

3.3.1

Link to section 'Commands' of 'intarna' Commands

IntaRNA

Link to section 'Module' of 'intarna' Module

You can load the modules by:

module load biocontainers
module load intarna

Link to section 'Example job' of 'intarna' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Intarna on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=intarna
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers intarna

IntaRNA -t CCCCCCCCGGGGGGGGGGGGGG -q AAAACCCCCCCUUUU

interproscan

InterPro is a database which integrates together predictive information about proteins’ function from a number of partner resources, giving an overview of the families that a protein belongs to and the domains and sites it contains.

Users who have novel nucleotide or protein sequences that they wish to functionally characterise can use the software package InterProScan to run the scanning algorithms from the InterPro database in an integrated way. Sequences are submitted in FASTA format. Matches are then calculated against all of the required member database’s signatures and the results are then output in a variety of formats.

Link to section 'Versions' of 'interproscan' Versions

5.54_87.0

Link to section 'Commands' of 'interproscan' Commands

interproscan.sh

Link to section 'Database' of 'interproscan' Database

Latest version of database has been downloaded and setup in /depot/itap/datasets/interproscan-5.54-87.0/data.

Link to section 'Module' of 'interproscan' Module

You can load the modules by:

module load biocontainers
module load interproscan/5.54_87.0

Link to section 'Example job' of 'interproscan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run run_dbcan on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=interproscan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers interproscan/5.54_87.0

interproscan.sh -cpu 24 -i test_proteins.fasta
interproscan.sh -cpu 24 -t n -i test_nt_seqs.fasta

iqtree

Link to section 'Introduction' of 'iqtree' Introduction

IQ-TREE is an efficient phylogenomic software by maximum likelihood.

For more information, please check its website: https://biocontainers.pro/tools/iqtree and its home page: http://www.iqtree.org.

Link to section 'Versions' of 'iqtree' Versions

1.6.12
2.1.2
2.2.0_beta

Link to section 'Commands' of 'iqtree' Commands

iqtree

Link to section 'Module' of 'iqtree' Module

You can load the modules by:

module load biocontainers
module load iqtree

Link to section 'Example job' of 'iqtree' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run IQ-TREE on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=iqtree
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers iqtree

iqtree -s input.phy -m GTR+I+G > test.out

isoquant

Link to section 'Introduction' of 'isoquant' Introduction

IsoQuant is a tool for the genome-based analysis of long RNA reads, such as PacBio or Oxford Nanopores. IsoQuant allows to reconstruct and quantify transcript models with high precision and decent recall. If the reference annotation is given, IsoQuant also assigns reads to the annotated isoforms based on their intron and exon structure. IsoQuant further performs annotated gene, isoform, exon and intron quantification. If reads are grouped (e.g. according to cell type), counts are reported according to the provided grouping.

BioContainers: https://biocontainers.pro/tools/isoquant
Home page: https://github.com/ablab/IsoQuant

Link to section 'Versions' of 'isoquant' Versions

3.1.2

Link to section 'Commands' of 'isoquant' Commands

isoquant.py

Link to section 'Module' of 'isoquant' Module

You can load the modules by:

module load biocontainers
module load isoquant

Link to section 'Example job' of 'isoquant' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run isoquant on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=isoquant
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers isoquant

isoquant.py --reference chr9.4M.fa.gz \
    --genedb chr9.4M.gtf.gz \
    --fastq  chr9.4M.ont.sim.fq.gz \
    --data_type nanopore -o test_ont

isoseq3

Link to section 'Introduction' of 'isoseq3' Introduction

Isoseq3 - Scalable De Novo Isoform Discovery.

For more information, please check its website: https://biocontainers.pro/tools/isoseq3 and its home page on Github.

Link to section 'Versions' of 'isoseq3' Versions

3.4.0
3.7.0
3.8.2

Link to section 'Commands' of 'isoseq3' Commands

isoseq3

Link to section 'Module' of 'isoseq3' Module

You can load the modules by:

module load biocontainers
module load isoseq3

Link to section 'Example job' of 'isoseq3' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Isoseq3 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=isoseq3
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers isoseq3

isoseq3 --version

isoseq3 refine --require-polya \
    alz.demult.5p--3p.bam \
    primers.fasta alz.flnc.bam

isoseq3 cluster alz.flnc.bam \
    alz.polished.bam --verbose --use-qvs

ivar

Link to section 'Introduction' of 'ivar' Introduction

Ivar is a computational package that contains functions broadly useful for viral amplicon-based sequencing.

Docker hub: https://hub.docker.com/r/andersenlabapps/ivar/
Home page: https://github.com/andersen-lab/ivar

Link to section 'Versions' of 'ivar' Versions

1.3.1

Link to section 'Commands' of 'ivar' Commands

ivar

Link to section 'Module' of 'ivar' Module

You can load the modules by:

module load biocontainers
module load ivar

Link to section 'Example job' of 'ivar' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ivar on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ivar
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ivar

jcvi

Link to section 'Introduction' of 'jcvi' Introduction

Jcvi is a collection of Python libraries to parse bioinformatics files, or perform computation related to assembly, annotation, and comparative genomics.

Home page: https://github.com/tanghaibao/jcvi

Link to section 'Versions' of 'jcvi' Versions

1.2.7
1.3.1

Link to section 'Commands' of 'jcvi' Commands

python
python3

Link to section 'Module' of 'jcvi' Module

You can load the modules by:

module load biocontainers
module load jcvi

Link to section 'Example job' of 'jcvi' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run jcvi on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=jcvi
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers jcvi

python -m jcvi.formats.fasta format Vvinifera_145_Genoscope.12X.cds.fa.gz grape.cds
python -m jcvi.formats.fasta format Ppersica_298_v2.1.cds.fa.gz peach.cds
python -m jcvi.formats.gff bed --type=mRNA --key=Name --primary_only Vvinifera_145_Genoscope.12X.gene.gff3.gz -o grape.bed
python -m jcvi.compara.catalog ortholog grape peach --no_strip_names
python -m jcvi.graphics.dotplot grape.peach.anchors
rm grape.peach.last.filtered 
python -m jcvi.compara.catalog ortholog grape peach --cscore=.99 --no_strip_names
python -m jcvi.graphics.dotplot grape.peach.anchors
python -m jcvi.compara.synteny depth --histogram grape.peach.anchors
python -m jcvi.graphics.grabseeds seeds test-data/test.JPG

kaiju

Link to section 'Introduction' of 'kaiju' Introduction

Kaiju is a tool for fast taxonomic classification of metagenomic sequencing reads using a protein reference database.

For more information, please check its website: https://biocontainers.pro/tools/kaiju and its home page on Github.

Link to section 'Versions' of 'kaiju' Versions

1.8.2

Link to section 'Module' of 'kaiju' Module

You can load the modules by:

module load biocontainers
module load kaiju

Link to section 'Example job' of 'kaiju' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Kaiju on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=kaiju
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kaiju

kaiju -t kaijudb/nodes.dmp \
     -f kaijudb/refseq/kaiju_db_refseq.fmi \
    -i input_1.fastq -j input_2.fastq
     -z 24

kakscalculator2

Link to section 'Introduction' of 'kakscalculator2' Introduction

kakscalculator2 is a toolkit of incorporating gamma series methods and sliding window strategies.

Home page: https://github.com/kullrich/kakscalculator2

Link to section 'Versions' of 'kakscalculator2' Versions

2.0.1

Link to section 'Commands' of 'kakscalculator2' Commands

KaKs_Calculator

Link to section 'Module' of 'kakscalculator2' Module

You can load the modules by:

module load biocontainers
module load kakscalculator2

Link to section 'Example job' of 'kakscalculator2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kakscalculator2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kakscalculator2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kakscalculator2

KaKs_Calculator -i example.axt -o example.axt.kaks -m YN

kallisto

Kallisto is a program for quantifying abundances of transcripts from RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads. It is based on the novel idea of pseudoalignment for rapidly determining the compatibility of reads with targets, without the need for alignment.

Detailed usage can be found here: https://github.com/pachterlab/kallisto

Link to section 'Versions' of 'kallisto' Versions

0.46.2
0.48.0

Link to section 'Commands' of 'kallisto' Commands

kallisto

Link to section 'Module' of 'kallisto' Module

You can load the modules by:

module load biocontainers
module load kallisto/0.48.0

Link to section 'Example job' of 'kallisto' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kallisto on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=kallisto
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kallisto/0.48.0

kallisto index -i transcripts.idx Homo_sapiens.GRCh38.cds.all.fa.gz
kallisto quant -t 24 -i transcripts.idx -o output -b 100  SRR11614709_1.fastq  SRR11614709_2.fastq

khmer

Link to section 'Introduction' of 'khmer' Introduction

Khmer is a tool for k-mer counting, filtering, and graph traversal FTW!

For more information, please check its website: https://biocontainers.pro/tools/khmer and its home page on Github.

Link to section 'Versions' of 'khmer' Versions

3.0.0a3

Link to section 'Module' of 'khmer' Module

You can load the modules by:

module load biocontainers
module load khmer

Link to section 'Example job' of 'khmer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Khmer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=khmer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers khmer

kissde

Link to section 'Introduction' of 'kissde' Introduction

kissDE is a R package, similar to DEseq, but which works on pairs of variants, and tests if a variant is enriched in one condition. It has been developed to work easily with KisSplice output. It can also work with a simple table of counts obtained by any other means. It requires at least two replicates per condition and at least two conditions.

Docker hub: https://hub.docker.com/r/dwishsan/kissplice-pipeline
Home page: https://kissplice.prabi.fr

Link to section 'Versions' of 'kissde' Versions

1.15.3

Link to section 'Commands' of 'kissde' Commands

R
Rscript
kissDE.R

Link to section 'Module' of 'kissde' Module

You can load the modules by:

module load biocontainers
module load kissde

Link to section 'Example job' of 'kissde' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kissde on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kissde
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kissde

kissplice

Link to section 'Introduction' of 'kissplice' Introduction

KisSplice is a software that enables to analyse RNA-seq data with or without a reference genome. It is an exact local transcriptome assembler that allows to identify SNPs, indels and alternative splicing events. It can deal with an arbitrary number of biological conditions, and will quantify each variant in each condition. It has been tested on Illumina datasets of up to 1G reads. Its memory consumption is around 5Gb for 100M reads.

Docker hub: https://hub.docker.com/r/dwishsan/kissplice-pipeline
Home page: https://kissplice.prabi.fr

Link to section 'Versions' of 'kissplice' Versions

2.6.2

Link to section 'Commands' of 'kissplice' Commands

kissplice

Link to section 'Module' of 'kissplice' Module

You can load the modules by:

module load biocontainers
module load kissplice

Link to section 'Example job' of 'kissplice' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kissplice on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kissplice
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kissplice

kissplice2refgenome

Link to section 'Introduction' of 'kissplice2refgenome' Introduction

KisSplice can also be used when a reference (annotated) genome is available, in order to annotate the variants found and help prioritize cases to validate experimentally. In this case, the results of KisSplice are mapped to the reference genome, using for instance STAR, and the mapping results are analysed using KisSplice2RefGenome.

Docker hub: https://hub.docker.com/r/dwishsan/kissplice-pipeline
Home page: https://kissplice.prabi.fr

Link to section 'Versions' of 'kissplice2refgenome' Versions

2.0.8

Link to section 'Commands' of 'kissplice2refgenome' Commands

kissplice2refgenome

Link to section 'Module' of 'kissplice2refgenome' Module

You can load the modules by:

module load biocontainers
module load kissplice2refgenome

Link to section 'Example job' of 'kissplice2refgenome' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kissplice2refgenome on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kissplice2refgenome
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kissplice2refgenome

kma

Link to section 'Introduction' of 'kma' Introduction

KMA is a mapping method designed to map raw reads directly against redundant databases, in an ultra-fast manner using seed and extend.

BioContainers: https://biocontainers.pro/tools/kma
Home page: https://bitbucket.org/genomicepidemiology/kma/src/master/

Link to section 'Versions' of 'kma' Versions

1.4.3

Link to section 'Commands' of 'kma' Commands

kma
kma_index
kma_shm
kma_update

Link to section 'Module' of 'kma' Module

You can load the modules by:

module load biocontainers
module load kma

Link to section 'Example job' of 'kma' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kma on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kma
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kma

kmc

Link to section 'Introduction' of 'kmc' Introduction

Kmc is a tool for efficient k-mer counting and filtering of reads based on k-mer content.

For more information, please check its website: https://biocontainers.pro/tools/kmc and its home page on Github.

Link to section 'Versions' of 'kmc' Versions

3.2.1

Link to section 'Commands' of 'kmc' Commands

kmc
kmc_dump
kmc_tools

Link to section 'Module' of 'kmc' Module

You can load the modules by:

module load biocontainers
module load kmc

Link to section 'Example job' of 'kmc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Kmc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kmc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kmc

kmc -k27 seq.fastq 27mers .

kmer-jellyfish

Link to section 'Introduction' of 'kmer-jellyfish' Introduction

Jellyfish is a tool for fast, memory-efficient counting of k-mers in DNA. A k-mer is a substring of length k, and counting the occurrences of all such substrings is a central step in many analyses of DNA sequence.

For more information, please check its website: https://biocontainers.pro/tools/kmer-jellyfish and its home page: http://www.genome.umd.edu/jellyfish.html.

Link to section 'Versions' of 'kmer-jellyfish' Versions

2.3.0

Link to section 'Commands' of 'kmer-jellyfish' Commands

jellyfish

Link to section 'Module' of 'kmer-jellyfish' Module

You can load the modules by:

module load biocontainers
module load kmer-jellyfish

Link to section 'Example job' of 'kmer-jellyfish' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Jellyfish on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=kmer-jellyfish
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kmer-jellyfish

jellyfish count -m 16 -s 100M -t 12 \
     -o mer_counts -c 7  input.fastq

kmergenie

Link to section 'Introduction' of 'kmergenie' Introduction

KmerGenie estimates the best k-mer length for genome de novo assembly.

BioContainers: https://biocontainers.pro/tools/kmergenie
Home page: http://kmergenie.bx.psu.edu

Link to section 'Versions' of 'kmergenie' Versions

1.7051

Link to section 'Commands' of 'kmergenie' Commands

kmergenie

Link to section 'Module' of 'kmergenie' Module

You can load the modules by:

module load biocontainers
module load kmergenie

Link to section 'Example job' of 'kmergenie' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kmergenie on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kmergenie
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kmergenie

kneaddata

KneadData is a tool designed to perform quality control on metagenomic and metatranscriptomic sequencing data, especially data from microbiome experiments. In these experiments, samples are typically taken from a host in hopes of learning something about the microbial community on the host.

Detailed usage can be found here: https://huttenhower.sph.harvard.edu/kneaddata/

Link to section 'Versions' of 'kneaddata' Versions

0.10.0

Link to section 'Commands' of 'kneaddata' Commands

kneaddata
kneaddata_bowtie2_discordant_pairs
kneaddata_build_database
kneaddata_database
kneaddata_read_count_table
kneaddata_test
kneaddata_trf_parallel

Link to section 'Module' of 'kneaddata' Module

You can load the modules by:

module load biocontainers
module load kneaddata

Link to section 'Example job' of 'kneaddata' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kneaddata on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=kneaddata
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kneaddata

kneaddata --input examples/demo.fastq --reference-db examples/demo_db --output kneaddata_demo_outpu --threads 24 --processes 24

kover

Link to section 'Introduction' of 'kover' Introduction

Kover is an out-of-core implementation of rule-based machine learning algorithms that has been tailored for genomic biomarker discovery.

Docker hub: https://hub.docker.com/r/aldro61/kover
Home page: https://github.com/aldro61/kover

Link to section 'Versions' of 'kover' Versions

2.0.6

Link to section 'Commands' of 'kover' Commands

kover

Link to section 'Module' of 'kover' Module

You can load the modules by:

module load biocontainers
module load kover

Link to section 'Example job' of 'kover' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kover on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=kover
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kover

kraken2

Kraken2 is the newest version of Kraken, a taxonomic classification system using exact k-mer matches to achieve high accuracy and fast classification speeds. This classifier matches each k-mer within a query sequence to the lowest common ancestor (LCA) of all genomes containing the given k-mer.

Detailed usage can be found here: https://ccb.jhu.edu/software/kraken2/

Link to section 'Versions' of 'kraken2' Versions

2.1.2_fixftp
2.1.2

Link to section 'Commands' of 'kraken2' Commands

kraken2
kraken2-build
kraken2-inspect

Link to section 'Module' of 'kraken2' Module

You can load the modules by:

module load biocontainers
module load kraken2/2.1.2

Download database

There is a known bug in rsync_from_ncbi.pl (https://github.com/DerrickWood/kraken2/issues/292). When users want to download and build databases by kraken2-build --download-library, there will an error rsync_from_ncbi.pl: unexpected FTP path(new server?). We modified rsync_from_ncbi.pl to fix the bug, and created a new module ending with the suffix _fixftp. Please use this corrected module to download the library.

To download databases, please use the below command:

module load biocontainers
module load kraken2/2.1.2_fixftp

kraken2-build --download-library archaea --db archaea

Link to section 'Example job' of 'kraken2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run kraken2 on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=kraken2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers kraken2/2.1.2

kraken2 --threads 24  --report kranken2.report --db minikraken2_v2_8GB_201904_UPDATE --paired --classified-out cseqs#.fq SRR5043021_1.fastq SRR5043021_2.fastq

krakentools

KrakenTools provides individual scripts to analyze Kraken/Kraken2/Bracken/KrakenUniq output files.

Detailed usage can be found here: https://github.com/jenniferlu717/KrakenTools

Link to section 'Versions' of 'krakentools' Versions

Link to section 'Module' of 'krakentools' Module

You can load the modules by:

module load biocontainers
module load krakentools/1.2

Link to section 'Example job' of 'krakentools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run krakentools on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=krakentools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers krakentools/1.2

extract_kraken_reads.py -k myfile.kraken -t 2 -s1 SRR5043021_1.fastq -s2 SRR5043021_2.fastq -o extracted1.fq -o2 extracted2.fq

lambda

Link to section 'Introduction' of 'lambda' Introduction

Lambda is a local aligner optimized for many query sequences and searches in protein space.

For more information, please check its website: https://biocontainers.pro/tools/lambda and its home page: http://seqan.github.io/lambda/.

Link to section 'Versions' of 'lambda' Versions

2.0.0

Link to section 'Commands' of 'lambda' Commands

lambda2

Link to section 'Module' of 'lambda' Module

You can load the modules by:

module load biocontainers
module load lambda

Link to section 'Example job' of 'lambda' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Lambda on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=lambda
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lambda

lambda2 mkindexp -d uniprot_sprot.fasta

lambda2 searchp \
    -q proteins.fasta \
    -i uniprot_sprot.fasta.lambda

last

Link to section 'Introduction' of 'last' Introduction

Last is used to find & align related regions of sequences.

For more information, please check its website: https://biocontainers.pro/tools/last and its home page on Gitlab.

Link to section 'Versions' of 'last' Versions

1268
1356
1411
1418

Link to section 'Module' of 'last' Module

You can load the modules by:

module load biocontainers
module load last

Link to section 'Example job' of 'last' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Last on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=last
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers last

lastdb humdb humanMito.fa
lastal humdb fuguMito.fa > myalns.maf

lastz

Link to section 'Introduction' of 'lastz' Introduction

LASTZ - pairwise DNA sequence aligner

BioContainers: https://biocontainers.pro/tools/lastz
Home page: https://github.com/lastz/lastz

Link to section 'Versions' of 'lastz' Versions

1.04.15

Link to section 'Commands' of 'lastz' Commands

lastz
lastz_32
lastz_D

Link to section 'Module' of 'lastz' Module

You can load the modules by:

module load biocontainers
module load lastz

Link to section 'Example job' of 'lastz' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run lastz on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=lastz
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lastz

lastz cmc_CFBP8216.fasta cmp_LPPA982.fasta \
     --notransition --step=20 --nogapped \
     --format=maf > cmc_vs_cmp.maf

ldhat

Link to section 'Introduction' of 'ldhat' Introduction

LDhat is a package written in the C and C++ languages for the analysis of recombination rates from population genetic data.

Home page: https://github.com/auton1/LDhat

Link to section 'Versions' of 'ldhat' Versions

2.2a

Link to section 'Commands' of 'ldhat' Commands

convert
pairwise
interval
rhomap
fin

Link to section 'Module' of 'ldhat' Module

You can load the modules by:

module load biocontainers
module load ldhat

Link to section 'Example job' of 'ldhat' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ldhat on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ldhat
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ldhat

ldjump

Link to section 'Introduction' of 'ldjump' Introduction

LDJump is an R package to estimate variable recombination rates from population genetic data.

Home page: https://github.com/PhHermann/LDJump

Link to section 'Versions' of 'ldjump' Versions

0.3.1

Link to section 'Commands' of 'ldjump' Commands

R
Rscript

Link to section 'Module' of 'ldjump' Module

You can load the modules by:

module load biocontainers
module load ldjump

A full path to the Phi file of PhiPack needs to be provided as follows pathPhi = "/opt/PhiPack/Phi". In order to use LDhat to quickly calculate some of the summary statistics, please set pathLDhat = "/opt/LDhat/".

Link to section 'Interactive job' of 'ldjump' Interactive job

To run interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers ldjump
(base) UserID@bell-a008:~ $ R

R version 4.2.1 (2022-06-23) -- "Funny-Looking Kid"
Copyright (C) 2022 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.


> library(LDJump)
> LDJump(seqFullPath, alpha = 0.05, segLength = 1000, pathLDhat = "/opt/LDhat/", pathPhi = "/opt/PhiPack/Phi", format = "fasta", refName = NULL, 
   start = NULL, constant = F, status = T, cores = 1, accept = F, demography = F, out = "")

Link to section 'Batch job' of 'ldjump' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ldjump on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ldjump
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ldjump
Rscript script.R

ldsc

Link to section 'Introduction' of 'ldsc' Introduction

ldsc is a command line tool for estimating heritability and genetic correlation from GWAS summary statistics.

BioContainers: https://biocontainers.pro/tools/ldsc
Home page: https://github.com/bulik/ldsc

Link to section 'Versions' of 'ldsc' Versions

1.0.1

Link to section 'Commands' of 'ldsc' Commands

ldsc.py
munge_sumstats.py

Link to section 'Module' of 'ldsc' Module

You can load the modules by:

module load biocontainers
module load ldsc

Link to section 'Example job' of 'ldsc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ldsc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ldsc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ldsc

liftoff

Link to section 'Introduction' of 'liftoff' Introduction

Liftoff is an accurate GFF3/GTF lift over pipeline.

For more information, please check its website: https://biocontainers.pro/tools/liftoff and its home page on Github.

Link to section 'Versions' of 'liftoff' Versions

1.6.3

Link to section 'Commands' of 'liftoff' Commands

liftoff
python
python3

Link to section 'Module' of 'liftoff' Module

You can load the modules by:

module load biocontainers
module load liftoff

Link to section 'Example job' of 'liftoff' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Liftoff on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=liftoff
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers liftoff

liftoff -g reference.gff3 -o target.gff3 \
    -chroms chr_pairs.txt target.fasta reference.fa

liftofftools

Link to section 'Introduction' of 'liftofftools' Introduction

LiftoffTools is a toolkit to compare genes lifted between genome assemblies. Specifically it is designed to compare genes lifted over using Liftoff although it is also compatible with other lift-over tools such as UCSC liftOver as long as the feature IDs are the same. LiftoffTools provides 3 different modules. The first identifies variants in protein-coding genes and their effects on the gene. The second compares the gene synteny, and the third clusters genes into groups of paralogs to evaluate gene copy number gain and loss. The input for all modules is the reference genome assembly (FASTA), target genome assembly (FASTA), reference annotation (GFF/GTF), and target annotation (GFF/GTF).

BioContainers: https://biocontainers.pro/tools/liftofftools
Home page: https://github.com/agshumate/LiftoffTools

Link to section 'Versions' of 'liftofftools' Versions

0.4.4

Link to section 'Commands' of 'liftofftools' Commands

liftofftools

Link to section 'Module' of 'liftofftools' Module

You can load the modules by:

module load biocontainers
module load liftofftools

Link to section 'Example job' of 'liftofftools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run liftofftools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=liftofftools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers liftofftools

lima

Link to section 'Introduction' of 'lima' Introduction

Lima is the standard tool to identify barcode and primer sequences in PacBio single-molecule sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/lima and its home page: https://lima.how.

Link to section 'Versions' of 'lima' Versions

2.2.0

Link to section 'Commands' of 'lima' Commands

lima

Link to section 'Module' of 'lima' Module

You can load the modules by:

module load biocontainers
module load lima

Link to section 'Example job' of 'lima' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Lima on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=lima
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lima

lima --version
lima --isoseq --dump-clips \
    --peek-guess -j 12 \
    alz.ccs.bam primers.fasta \
    alz.demult.bam

links

Link to section 'Introduction' of 'links' Introduction

LINKS is a genomics application for scaffolding genome assemblies with long reads, such as those produced by Oxford Nanopore Technologies Ltd. It can be used to scaffold high-quality draft genome assemblies with any long sequences (eg. ONT reads, PacBio reads, other draft genomes, etc). It is also used to scaffold contig pairs linked by ARCS/ARKS.

BioContainers: https://biocontainers.pro/tools/links
Home page: https://github.com/bcgsc/LINKS

Link to section 'Versions' of 'links' Versions

2.0.1

Link to section 'Commands' of 'links' Commands

LINKS

Link to section 'Module' of 'links' Module

You can load the modules by:

module load biocontainers
module load links

Link to section 'Example job' of 'links' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run links on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=links
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers links

lofreq

Link to section 'Introduction' of 'lofreq' Introduction

Lofreq is a fast and sensitive variant-caller for inferring SNVs and indels from next-generation sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/lofreq and its home page on Github.

Link to section 'Versions' of 'lofreq' Versions

2.1.5

Link to section 'Commands' of 'lofreq' Commands

lofreq

Link to section 'Module' of 'lofreq' Module

You can load the modules by:

module load biocontainers
module load lofreq

Link to section 'Example job' of 'lofreq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Lofreq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=lofreq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lofreq

lofreq  call -f ref.fa -o vars.vcf out_sorted.bam

lofreq call-parallel --pp-threads 8 \
     -f ref.fa -o vars_pallel.vcf out_sorted.bam

longphase

Link to section 'Introduction' of 'longphase' Introduction

LongPhase is an ultra-fast program for simultaneously co-phasing SNPs and SVs by using Nanopore and PacBio long reads. It is capable of producing nearly chromosome-scale haplotype blocks by using Nanpore ultra-long reads without the need for additional trios, chromosome conformation, and strand-seq data. On an 8-core machine, LongPhase can finish phasing a human genome in 10-20 minutes.

Docker hub: https://hub.docker.com/r/alexanrna/longphase
Home page: https://github.com/twolinin/longphase

Link to section 'Versions' of 'longphase' Versions

Link to section 'Commands' of 'longphase' Commands

longphase

Link to section 'Module' of 'longphase' Module

You can load the modules by:

module load biocontainers
module load longphase

Link to section 'Example job' of 'longphase' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run longphase on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=longphase
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers longphase

longphase phase \
    -s SNP.vcf \
    --sv-file SV.vcf \
    -b alignment.bam \
    -r reference.fasta \
    -t 8 \
    -o phased_prefix \
    --ont # or --pb for PacBio Hifi

longqc

Link to section 'Introduction' of 'longqc' Introduction

LongQC is a tool for the data quality control of the PacBio and ONT long reads.

Docker hub: https://hub.docker.com/r/cymbopogon/longqc
Home page: https://github.com/yfukasawa/LongQC

Link to section 'Versions' of 'longqc' Versions

1.2.0c

Link to section 'Commands' of 'longqc' Commands

longQC.py

Link to section 'Module' of 'longqc' Module

You can load the modules by:

module load biocontainers
module load longqc

Link to section 'Example job' of 'longqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run longqc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=longqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers longqc

longQC.py sampleqc -x pb-rs2 -o out_dir seq.fastq

lra

Link to section 'Introduction' of 'lra' Introduction

Lra is a sequence alignment program that aligns long reads from single-molecule sequencing (SMS) instruments, or megabase-scale contigs from SMS assemblies.

For more information, please check its website: https://biocontainers.pro/tools/lra and its home page on Github.

Link to section 'Versions' of 'lra' Versions

1.3.2

Link to section 'Commands' of 'lra' Commands

Link to section 'Module' of 'lra' Module

You can load the modules by:

module load biocontainers
module load lra

Link to section 'Example job' of 'lra' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Lra on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=lra
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lra

lra index genome.fasta

lra align genome.fasta input.fastq -t 12 -p s > output.sam

ltr_finder

Link to section 'Introduction' of 'ltr_finder' Introduction

LTR_Finder is an efficient program for finding full-length LTR retrotranspsons in genome sequences.

Home page: https://github.com/xzhub/LTR_Finder

Link to section 'Versions' of 'ltr_finder' Versions

1.07

Link to section 'Commands' of 'ltr_finder' Commands

ltr_finder
check_result.pl
down_tRNA.pl
filter_rt.pl
genome_plot.pl
genome_plot2.pl
genome_plot_svg.pl

Link to section 'Module' of 'ltr_finder' Module

You can load the modules by:

module load biocontainers
module load ltr_finder

Link to section 'Example job' of 'ltr_finder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ltr_finder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ltr_finder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ltr_finder

ltr_finder 3ds_72.fa -P 3ds_72 -w2  > test/3ds_72_result.txt \
    |   genome_plot.pl test/

ltrpred

Link to section 'Introduction' of 'ltrpred' Introduction

LTRpred(ict): de novo annotation of young and intact retrotransposons.

Docker hub: https://hub.docker.com/r/drostlab/ltrpred
Home page: https://github.com/HajkD/LTRpred

Link to section 'Versions' of 'ltrpred' Versions

1.1.0

Link to section 'Commands' of 'ltrpred' Commands

R
Rscript

Link to section 'Module' of 'ltrpred' Module

You can load the modules by:

module load biocontainers
module load ltrpred

Link to section 'Example job' of 'ltrpred' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ltrpred on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ltrpred
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ltrpred

lumpy-sv

Link to section 'Introduction' of 'lumpy-sv' Introduction

Lumpy-sv is a general probabilistic framework for structural variant discovery.

For more information, please check its website: https://biocontainers.pro/tools/lumpy-sv and its home page on Github.

Link to section 'Versions' of 'lumpy-sv' Versions

0.3.1

Link to section 'Commands' of 'lumpy-sv' Commands

lumpy
lumpyexpress

Link to section 'Module' of 'lumpy-sv' Module

You can load the modules by:

module load biocontainers
module load lumpy-sv

Link to section 'Example job' of 'lumpy-sv' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Lumpy-sv on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=lumpy-sv
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lumpy-sv

lumpy -mw 4 -tt 0.0 -pe \
bam_file:AL87.discordant.sort.bam,histo_file:AL87.histo,mean:429,stdev:84,read_length:83,min_non_overlap:83,discordant_z:4,back_distance:1,weight:1,id:1,min_mapping_threshold:20 \
-sr bam_file:AL87.sr.sort.bam,back_distance:1,weight:1,id:2,min_mapping_threshold:20

lyveset

Link to section 'Introduction' of 'lyveset' Introduction

Lyveset is a method of using hqSNPs to create a phylogeny, especially for outbreak investigations.

Docker hub: https://hub.docker.com/r/staphb/lyveset
Home page: https://github.com/lskatz/lyve-SET

Link to section 'Versions' of 'lyveset' Versions

2.0.1

Link to section 'Module' of 'lyveset' Module

You can load the modules by:

module load biocontainers
module load lyveset

Link to section 'Example job' of 'lyveset' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run lyveset on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=lyveset
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers lyveset

set_test.pl lambda
set_manage.pl --create setTest

macrel

Link to section 'Introduction' of 'macrel' Introduction

Macrel is a pipeline to mine antimicrobial peptides (AMPs) from (meta)genomes.

BioContainers: https://biocontainers.pro/tools/macrel
Home page: https://github.com/BigDataBiology/macrel

Link to section 'Versions' of 'macrel' Versions

1.2.0

Link to section 'Commands' of 'macrel' Commands

macrel

Link to section 'Module' of 'macrel' Module

You can load the modules by:

module load biocontainers
module load macrel

Link to section 'Example job' of 'macrel' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run macrel on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=macrel
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers macrel

macs2

Link to section 'Introduction' of 'macs2' Introduction

MACS2 is Model-based Analysis of ChIP-Seq for identifying transcript factor binding sites.

MACS consists of four steps:

removing redundant reads
adjusting read position
calculating peak enrichment
estimating the empirical false discovery rate (FDR).

For more information, please check its website: https://biocontainers.pro/tools/macs2 and its home page on Github.

Link to section 'Versions' of 'macs2' Versions

2.2.7.1

Link to section 'Commands' of 'macs2' Commands

macs2

Link to section 'Module' of 'macs2' Module

You can load the modules by:

module load biocontainers
module load macs2

Link to section 'Example job' of 'macs2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MACS2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=macs2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers macs2

macs2 callpeak -t ChIP.bam -c Control.bam -f BAM -g hs -n test -B -q 0.01

macs3

Link to section 'Introduction' of 'macs3' Introduction

MACS3 is Model-based Analysis of ChIP-Seq for identifying transcript factor.

Docker hub: https://hub.docker.com/r/lbmc/macs3/3.0.0a6 and its home page on Github.

Link to section 'Versions' of 'macs3' Versions

3.0.0a6

Link to section 'Commands' of 'macs3' Commands

macs3

Link to section 'Module' of 'macs3' Module

You can load the modules by:

module load biocontainers
module load macs3

Link to section 'Example job' of 'macs3' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Macs3 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=macs3
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers macs3

macs3 callpeak -t ChIP.bam -c Control.bam -f BAM -g hs -n test -B -q 0.01

mafft

Link to section 'Introduction' of 'mafft' Introduction

MAFFT is a multiple alignment program for amino acid or nucleotide sequences.

For more information, please check its website: https://biocontainers.pro/tools/mafft and its home page: https://mafft.cbrc.jp/alignment/software/.

Link to section 'Versions' of 'mafft' Versions

7.475
7.490

Link to section 'Module' of 'mafft' Module

You can load the modules by:

module load biocontainers
module load mafft

Link to section 'Example job' of 'mafft' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MAFFT on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mafft
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mafft

mageck

Link to section 'Introduction' of 'mageck' Introduction

Model-based Analysis of Genome-wide CRISPR-Cas9 Knockout (MAGeCK) is a computational tool to identify important genes from the recent genome-scale CRISPR-Cas9 knockout screens (or GeCKO) technology.

Docker hub: https://hub.docker.com/r/davidliwei/mageck
Home page: https://bitbucket.org/liulab/mageck/src/master/

Link to section 'Versions' of 'mageck' Versions

0.5.9.5

Link to section 'Commands' of 'mageck' Commands

mageck
mageckGSEA
RRA

Link to section 'Module' of 'mageck' Module

You can load the modules by:

module load biocontainers
module load mageck

Link to section 'Example job' of 'mageck' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mageck on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mageck
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mageck


mageck count -l library.txt -n demo \
     --sample-label L1,CTRL \
     --fastq test1.fastq test2.fastq

mageck test -k demo.count.txt \
     -t L1 -c CTRL -n demo

magicblast

Link to section 'Introduction' of 'magicblast' Introduction

Magic-BLAST is a tool for mapping large next-generation RNA or DNA sequencing runs against a whole genome or transcriptome. Each alignment optimizes a composite score, taking into account simultaneously the two reads of a pair, and in case of RNA-seq, locating the candidate introns and adding up the score of all exons. This is very different from other versions of BLAST, where each exon is scored as a separate hit and read-pairing is ignored.

Docker hub: https://hub.docker.com/r/ncbi/magicblast
Home page: https://ncbi.github.io/magicblast/

Link to section 'Versions' of 'magicblast' Versions

1.5.0

Link to section 'Commands' of 'magicblast' Commands

magicblast

Link to section 'Module' of 'magicblast' Module

You can load the modules by:

module load biocontainers
module load magicblast

Link to section 'Example job' of 'magicblast' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run magicblast on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=magicblast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers magicblast

maker

Link to section 'Introduction' of 'maker' Introduction

MAKER is a popular genome annotation pipeline for both prokaryotic and eukaryotic genomes. This guide describes best practices for running MAKER on RCAC clusters. For detailed information about MAKER, see its official website (http://weatherby.genetics.utah.edu/MAKER/wiki/index.php/MAKER_Tutorial_for_WGS_Assembly_and_Annotation_Winter_School_2018).

Link to section 'Versions' of 'maker' Versions

2.31.11
3.01.03

Link to section 'Module' of 'maker' Module

You can load the modules by:

module load biocontainers
module load maker/2.31.11 # OR maker/3.01.03

Dfam release 3.5 (October 2021) downloaded from Dfam website (https://www.dfam.org/home) that required by RepeatMasker has been set up for users. The RepeatMakser library is stored here /depot/itap/datasets/Maker/RepeatMasker/Libraries.

Link to section 'Prerequisites' of 'maker' Prerequisites

After loading MAKER modules, users can create MAKER control files by the following comand: maker -CTL This will generate three files:
maker_opts.ctl (required to be modified)
maker_exe.ctl (do not need to modify this file)
maker_bopts.ctl (optionally modify this file)
maker_opts.ctl:

If not using RepeatMasker, modify model_org=all to model_org=
If not using RepeatMasker, modify model_org=all to an appropriate family/genus/species.

Link to section 'Example job non-mpi' of 'maker' Example job non-mpi

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MAKER on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=MAKER
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers maker/2.31.11  # or maker/3.01.03 

maker -c 24

Link to section 'Example job mpi' of 'maker' Example job mpi

To use MAKER in MPI mode, we cannot use the maker modules. Instead we have to use the singularity image files stored in /apps/biocontainers/images:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 5:00:00
#SBATCH -N 2
#SBATCH -n 24
#SBATCH -c 8
#SBATCH --job-name=MAKER_mpi
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --mail-user=UserID@purdue.edu
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out
 
## MAKER2
mpirun -n 24 singularity exec /apps/biocontainers/images/maker_2.31.11.sif maker -c 8

## MAKER3
mpirun -n 24 singularity exec /apps/biocontainers/images/maker_3.01.03.sif maker -c 8

manta

Link to section 'Introduction' of 'manta' Introduction

Manta calls structural variants (SVs) and indels from mapped paired-end sequencing reads.

BioContainers: https://biocontainers.pro/tools/manta
Home page: https://github.com/Illumina/manta

Link to section 'Versions' of 'manta' Versions

1.6.0

Link to section 'Commands' of 'manta' Commands

configManta.py
python

Link to section 'Module' of 'manta' Module

You can load the modules by:

module load biocontainers
module load manta

Link to section 'Example job' of 'manta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run manta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=manta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers manta

configManta.py --normalBam=HCC1954.NORMAL.30x.compare.COST16011_region.bam \
    --tumorBam=G15512.HCC1954.1.COST16011_region.bam \
    --referenceFasta=Homo_sapiens_assembly19.COST16011_region.fa \
    --region=8:107652000-107655000 \
    --region=11:94974000-94989000 \
    --exome --runDir="MantaDemoAnalysis"

 python MantaDemoAnalysis/runWorkflow.py

mapcaller

Link to section 'Introduction' of 'mapcaller' Introduction

Mapcaller is an efficient and versatile approach for short-read mapping and variant identification using high-throughput sequenced data.

For more information, please check its website: https://biocontainers.pro/tools/mapcaller and its home page on Github.

Link to section 'Versions' of 'mapcaller' Versions

0.9.9.41

Link to section 'Commands' of 'mapcaller' Commands

MapCaller

Link to section 'Module' of 'mapcaller' Module

You can load the modules by:

module load biocontainers
module load mapcaller

Link to section 'Example job' of 'mapcaller' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mapcaller on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=mapcaller
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mapcaller

MapCaller index ref.fasta ref

MapCaller -t 12 -i ref -f input_1.fastq  -f2 input_2.fastq  -vcf out.vcf

marginpolish

Link to section 'Introduction' of 'marginpolish' Introduction

MarginPolish is a graph-based assembly polisher. It iteratively finds multiple probable alignment paths for run-length-encoded reads and uses these to generate a refined sequence. It takes as input a FASTA assembly and an indexed BAM (ONT reads aligned to the assembly), and it produces a polished FASTA assembly.

Docker hub: https://hub.docker.com/r/kishwars/margin_polish
Home page: https://github.com/UCSC-nanopore-cgl/MarginPolish

Link to section 'Versions' of 'marginpolish' Versions

0.1.3

Link to section 'Commands' of 'marginpolish' Commands

marginpolish

Link to section 'Module' of 'marginpolish' Module

You can load the modules by:

module load biocontainers
module load marginpolish

Link to section 'Example job' of 'marginpolish' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run marginpolish on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 32
#SBATCH --job-name=marginpolish
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers marginpolish
    
marginpolish \
    Reads_to_assembly_StaphAur.bam \
    Draft_assembly_StaphAur.fasta \
    helen_modles/MP_r941_guppy344_microbial.json \
    -t 32 \
    -o mp_output/mp_images \
    -f

mash

Link to section 'Introduction' of 'mash' Introduction

Mash is a fast sequence distance estimator that uses MinHash.

For more information, please check its website: https://biocontainers.pro/tools/mash and its home page on Github.

Link to section 'Versions' of 'mash' Versions

Link to section 'Commands' of 'mash' Commands

mash

Link to section 'Module' of 'mash' Module

You can load the modules by:

module load biocontainers
module load mash

Link to section 'Example job' of 'mash' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mash on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mash
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mash

mash dist genome1.fasta genome2.fasta

mashmap

Link to section 'Introduction' of 'mashmap' Introduction

Mashmap is a fast approximate aligner for long DNA sequences.

For more information, please check its website: https://biocontainers.pro/tools/mashmap and its home page on Github.

Link to section 'Versions' of 'mashmap' Versions

2.0-pl5321

Link to section 'Commands' of 'mashmap' Commands

mashmap

Link to section 'Module' of 'mashmap' Module

You can load the modules by:

module load biocontainers
module load mashmap

Link to section 'Example job' of 'mashmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mashmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=mashmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mashmap

mashmap -r ref.fasta -t 12 -q input.fasta

mashtree

Link to section 'Introduction' of 'mashtree' Introduction

Mashtree is a tool to create a tree using Mash distances.

For more information, please check its website: https://biocontainers.pro/tools/mashtree and its home page on Github.

Link to section 'Versions' of 'mashtree' Versions

1.2.0

Link to section 'Commands' of 'mashtree' Commands

mashtree
mashtree_bootstrap.pl
mashtree_cluster.pl
mashtree_init.pl
mashtree_jackknife.pl
mashtree_wrapper_deprecated.pl

Link to section 'Module' of 'mashtree' Module

You can load the modules by:

module load biocontainers
module load mashtree

Link to section 'Example job' of 'mashtree' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mashtree on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mashtree
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mashtree

masurca

Link to section 'Introduction' of 'masurca' Introduction

The MaSuRCA (Maryland Super Read Cabog Assembler) genome assembly and analysis toolkit contains of MaSuRCA genome assembler, QuORUM error corrector for Illumina data, POLCA genome polishing software, Chromosome scaffolder, jellyfish mer counter, and MUMmer aligner.

Docker hub: https://hub.docker.com/r/staphb/masurca
Home page: https://github.com/alekseyzimin/masurca

Link to section 'Versions' of 'masurca' Versions

4.0.9

Link to section 'Module' of 'masurca' Module

You can load the modules by:

module load biocontainers
module load masurca

Link to section 'Example job' of 'masurca' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run masurca on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=masurca
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers masurca

mauve

Link to section 'Introduction' of 'mauve' Introduction

Mauve is a system for constructing multiple genome alignments in the presence of large-scale evolutionary events such as rearrangement and inversion.

For more information, please check its website: https://biocontainers.pro/tools/mauve.

Link to section 'Versions' of 'mauve' Versions

2.4.0

Link to section 'Commands' of 'mauve' Commands

mauveAligner
progressiveMauve

Link to section 'Module' of 'mauve' Module

You can load the modules by:

module load biocontainers
module load mauve

Link to section 'Example job' of 'mauve' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mauve on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mauve
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mauve

mauveAligner seqs.fasta --output=mauveAligner_output

progressiveMauve --output=threeway.xmfa \
    --output-guide-tree=threeway.tree \
    --backbone-output=threeway.backbone genome1.gbk genome2.gbk genome3.gbk

maxbin2

Link to section 'Introduction' of 'maxbin2' Introduction

Maxbin2 is a software for binning assembled metagenomic sequences based on an Expectation-Maximization algorithm.

Docker hub: https://hub.docker.com/r/nanozoo/maxbin2
Home page: https://sourceforge.net/projects/maxbin2/

Link to section 'Versions' of 'maxbin2' Versions

2.2.7

Link to section 'Commands' of 'maxbin2' Commands

run_MaxBin.pl
run_FragGeneScan.pl

Link to section 'Module' of 'maxbin2' Module

You can load the modules by:

module load biocontainers
module load maxbin2

Link to section 'Example job' of 'maxbin2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run maxbin2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=maxbin2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers maxbin2

run_MaxBin.pl -contig subset_assembly.fa \
     -abund_list abundance.list -max_iteration 5 -out mbin

maxquant

Link to section 'Introduction' of 'maxquant' Introduction

Maxquant is a quantitative proteomics software package designed for analyzing large mass-spectrometric data sets. It is specifically aimed at high-resolution MS data.

For more information, please check home page: https://www.maxquant.org.

Link to section 'Versions' of 'maxquant' Versions

2.1.0.0
2.1.3.0
2.1.4.0
2.3.1.0

Link to section 'Commands' of 'maxquant' Commands

MaxQuantGui.exe
MaxQuantCmd.exe

Link to section 'Module' of 'maxquant' Module

You can load the modules by:

module load biocontainers
module load maxquant

Link to section 'GUI' of 'maxquant' GUI

To run Maxquant with GUI, it is recommended to run within ThinLinc:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers maxquant
(base) UserID@bell-a008:~ $ MaxQuantGui.exe

maxquant QUI

Link to section 'CMD job' of 'maxquant' CMD job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Maxquant without GUI on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=maxquant
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers maxquant

MaxQuantCmd.exe mqpar.xml

mcl

Link to section 'Introduction' of 'mcl' Introduction

Mcl is short for the Markov Cluster Algorithm, a fast and scalable unsupervised cluster algorithm for graphs.

For more information, please check its website: https://biocontainers.pro/tools/mcl and its home page: http://micans.org/mcl/.

Link to section 'Versions' of 'mcl' Versions

14.137-pl5262

Link to section 'Module' of 'mcl' Module

You can load the modules by:

module load biocontainers
module load mcl

Link to section 'Example job' of 'mcl' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mcl on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mcl
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mcl

mcscanx

The MCScanX package has two major components: a modified version of MCscan algorithm allowing users to handle MCScan more conveniently and to view multiple alignment of syntenic blocks more clearly, and a variety of downstream analysis tools to conduct different biological analyses based on the synteny data generated by the modified MCScan algorithm.

Home page: https://github.com/wyp1125/MCScanX.

Link to section 'Versions' of 'mcscanx' Versions

default

Link to section 'Introduction' of 'mcscanx' Introduction

Link to section 'Module' of 'mcscanx' Module

You can load the modules by:

module load biocontainers
module load mcscanx

Helper command

To conduct downstream analyses, users need to copy the folder downstream_analyses from container into the host system.

A helper command copy_downstream_analyses is provided to simplify the task. Follow the procedure below to copy downstream_analyses into target directory:

$ copy_downstream_analyses $PWD # this will copy the downstream_analyses into the current directory.

Link to section 'Example job' of 'mcscanx' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mcscanx on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mcscanx
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mcscanx

## Run MCScanX
MCScanX Result/merge
## Copy downstream_analyses
copy_downstream_analyses $PWD
## Downstream analyses   
java circle_plotter -g ../Result/merge.gff -s ../Result/merge.collinearity -c ../Result/merge_circ.ctl -o ../Result/merge_circle.png
java dot_plotter -g ../Result/merge.gff -s ../Result/merge.collinearity -c ../Result/merge_dot.ctl -o ../Result/merge_dot.png
java dual_synteny_plotter -g ../Result/merge.gff -s ../Result/merge.collinearity -c ../Result/merge_dot.ctl -o ../Result/merge_dual_synteny.png

medaka

Link to section 'Introduction' of 'medaka' Introduction

Medaka is a tool to create consensus sequences and variant calls from nanopore sequencing data.

Docker hub: https://hub.docker.com/r/ontresearch/medaka and its home page on Github.

Link to section 'Versions' of 'medaka' Versions

1.6.0

Link to section 'Commands' of 'medaka' Commands

medaka
medaka_consensus
medaka_counts
medaka_data_path
medaka_haploid_variant
medaka_version_report

Link to section 'Module' of 'medaka' Module

You can load the modules by:

module load biocontainers
module load medaka

Link to section 'Example job' of 'medaka' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Medaka on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=medaka
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers medaka

megadepth

Link to section 'Introduction' of 'megadepth' Introduction

Megadepth is an efficient tool for extracting coverage related information from RNA and DNA-seq BAM and BigWig files.

For more information, please check its website: https://biocontainers.pro/tools/megadepth and its home page on Github.

Link to section 'Versions' of 'megadepth' Versions

1.2.0

Link to section 'Commands' of 'megadepth' Commands

megadepth

Link to section 'Module' of 'megadepth' Module

You can load the modules by:

module load biocontainers
module load megadepth

Link to section 'Example job' of 'megadepth' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Megadepth on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=megadepth
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers megadepth

megadepth sorted.bam

megahit

Link to section 'Introduction' of 'megahit' Introduction

Megahit is a ultra-fast single-node solution for large and complex metagenomics assembly via succinct de Bruijn graph.

For more information, please check its website: https://biocontainers.pro/tools/megahit and its home page on Github.

Link to section 'Versions' of 'megahit' Versions

1.2.9

Link to section 'Commands' of 'megahit' Commands

megahit

Link to section 'Module' of 'megahit' Module

You can load the modules by:

module load biocontainers
module load megahit

Link to section 'Example job' of 'megahit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Megahit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=megahit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers megahit

megahit --12 SRR1976948.abundtrim.subset.pe.fq.gz,SRR1977249.abundtrim.subset.pe.fq.gz -o combined

megan

Link to section 'Introduction' of 'megan' Introduction

Megan is a computer program that allows optimized analysis of large metagenomic datasets. Metagenomics is the analysis of the genomic sequences from a usually uncultured environmental sample.

For more information, please check its website: https://biocontainers.pro/tools/megan and its home page: https://uni-tuebingen.de/fakultaeten/mathematisch-naturwissenschaftliche-fakultaet/fachbereiche/informatik/lehrstuehle/algorithms-in-bioinformatics/software/megan6/.

Link to section 'Versions' of 'megan' Versions

6.21.7

Link to section 'Module' of 'megan' Module

You can load the modules by:

module load biocontainers
module load megan

Link to section 'GUI' of 'megan' GUI

To run MEGAN with GUI, it is recommended to run within ThinLinc:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers megan
(base) UserID@bell-a008:~ $ MEGAN

Link to section 'Example job' of 'megan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Megan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=megan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers megan

meme

Link to section 'Introduction' of 'meme' Introduction

Meme is a collection of tools for the discovery and analysis of sequence motifs.

For more information, please check its website: https://biocontainers.pro/tools/meme and its home page: https://meme-suite.org/meme/.

Link to section 'Versions' of 'meme' Versions

5.3.3
5.4.1
5.5.0

Link to section 'Module' of 'meme' Module

You can load the modules by:

module load biocontainers
module load meme

Link to section 'Example job' of 'meme' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Meme on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=meme
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers meme

meme seq.fasta -dna -mod oops -pal

meme-chip Klf1.fna -o memechip_klf1_out

memes

Link to section 'Introduction' of 'memes' Introduction

memes is an R interface to the MEME Suite family of tools, which provides several utilities for performing motif analysis on DNA, RNA, and protein sequences. memes works by detecting a local install of the MEME suite, running the commands, then importing the results directly into R.

Docker hub: https://hub.docker.com/r/snystrom/memes_docker
Home page: https://github.com/snystrom/memes

Link to section 'Versions' of 'memes' Versions

1.1.2

Link to section 'Commands' of 'memes' Commands

Link to section 'Module' of 'memes' Module

You can load the modules by:

module load biocontainers
module load memes

Link to section 'Example job' of 'memes' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run memes on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=memes
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers memes

meraculous

Link to section 'Introduction' of 'meraculous' Introduction

Meraculous is a whole genome assembler for Next Generation Sequencing data, geared for large genomes. It is hybrid k-mer/read-based approach capitalizes on the high accuracy of Illumina sequence by eschewing an explicit error correction step which we argue to be redundant with the assembly process. Meraculous achieves high performance with large datasets by utilizing lightweight data structures and multi-threaded parallelization, allowing to assemble human-sized genomes on a high-cpu cluster in under a day. The process pipeline implements a highly transparent and portable model of job control and monitoring where different assembly stages can be executed and re-executed separately or in unison on a wide variety of architectures.

Home page: https://jgi.doe.gov/data-and-tools/software-tools/meraculous/

Link to section 'Versions' of 'meraculous' Versions

2.2.6

Link to section 'Module' of 'meraculous' Module

You can load the modules by:

module load biocontainers
module load meraculous

Link to section 'Example job' of 'meraculous' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run meraculous on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=meraculous
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers meraculous

merqury

Link to section 'Introduction' of 'merqury' Introduction

Merqury is a tool to evaluate genome assemblies with k-mers and more.

Docker hub: https://hub.docker.com/r/dovetailg/merqury
Home page: https://github.com/marbl/merqury

Link to section 'Versions' of 'merqury' Versions

Link to section 'Commands' of 'merqury' Commands

merqury.sh

Link to section 'Module' of 'merqury' Module

You can load the modules by:

module load biocontainers
module load merqury

Link to section 'Example job' of 'merqury' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run merqury on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=merqury
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers merqury

merqury.sh F1.k18.meryl col0.hapmer.meryl cvi0.hapmer.meryl \
    athal_COL.fasta athal_CVI.fasta test

meryl

Link to section 'Introduction' of 'meryl' Introduction

Meryl is a genomic k-mer counter (and sequence utility) with nice features.

For more information, please check its website: https://biocontainers.pro/tools/meryl and its home page on Github.

Link to section 'Versions' of 'meryl' Versions

Link to section 'Commands' of 'meryl' Commands

meryl
meryl-analyze
meryl-import
meryl-lookup
meryl-simple

Link to section 'Module' of 'meryl' Module

You can load the modules by:

module load biocontainers
module load meryl

Link to section 'Example job' of 'meryl' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Meryl on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=meryl
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers meryl

meryl count k=42 data/ec.fna.gz output ec.meryl

metabat

Link to section 'Introduction' of 'metabat' Introduction

Metabat is a robust statistical framework for reconstructing genomes from metagenomic data.

Docker hub: https://hub.docker.com/r/metabat/metabat and its home page: https://bitbucket.org/berkeleylab/metabat/src/master/

Link to section 'Versions' of 'metabat' Versions

2.15-5

Link to section 'Module' of 'metabat' Module

You can load the modules by:

module load biocontainers
module load metabat

Link to section 'Example job' of 'metabat' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Metabat on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=metabat
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers metabat

metabat2 -m 10000 \
    -t 24 \
    -i contig.fasta \
    -o metabat2_output \
    -a depth.txt

metachip

Link to section 'Introduction' of 'metachip' Introduction

Metachip is a pipeline for Horizontal gene transfer (HGT) identification.

BioContainers: https://biocontainers.pro/tools/metachip
Home page: https://github.com/songweizhi/MetaCHIP

Link to section 'Versions' of 'metachip' Versions

1.10.12

Link to section 'Commands' of 'metachip' Commands

MetaCHIP

Link to section 'Module' of 'metachip' Module

You can load the modules by:

module load biocontainers
module load metachip

Link to section 'Example job' of 'metachip' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run metachip on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=metachip
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers metachip

metaphlan

Link to section 'Introduction' of 'metaphlan' Introduction

MetaPhlAn (Metagenomic Phylogenetic Analysis) is a computational tool for profiling the composition of microbial communities from metagenomic shotgun sequencing data. MetaPhlAn relies on unique clade-specific marker genes identified from 17,000 reference genomes ( 13,500 bacterial and archaeal, 3,500 viral, and 110 eukaryotic), allowing:

up to 25,000 reads-per-second (on one CPU) analysis speed (orders of magnitude faster compared to existing methods);
unambiguous taxonomic assignments as the MetaPhlAn markers are clade-specific;
accurate estimation of organismal relative abundance (in terms of number of cells rather than fraction of reads);
species-level resolution for bacteria, archaea, eukaryotes and viruses;
extensive validation of the profiling accuracy on several synthetic datasets and on thousands of real metagenomes.

For more information, please check its user guide at: https://huttenhower.sph.harvard.edu/metaphlan/

Link to section 'Versions' of 'metaphlan' Versions

3.0.14
3.0.9
4.0.2

Commands
metaphlan

Link to section 'Database' of 'metaphlan' Database

The latest version of database(mpa_v30) has been downloaded and built in /depot/itap/datasets/metaphlan/.

Link to section 'Module' of 'metaphlan' Module

You can load the modules by:

module load biocontainers
module load metaphlan/3.0.14

Link to section 'Example job' of 'metaphlan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MetaPhlAn on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=MetaPhlAn
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers metaphlan/3.0.14

DATABASE=/depot/itap/datasets/metaphlan/
metaphlan SRR11234553_1.fastq,SRR11234553_2.fastq --input_type fastq --nproc 24 -o profiled_metagenome.txt --bowtie2db $DATABASE  --bowtie2out metagenome.bowtie2.bz2

metaseq

Link to section 'Introduction' of 'metaseq' Introduction

Metaseq is a Python package for integrative genome-wide analysis reveals relationships between chromatin insulators and associated nuclear mRNA.

Docker hub: https://hub.docker.com/r/vsmalladi/metaseq
Home page: https://github.com/daler/metaseq

Link to section 'Versions' of 'metaseq' Versions

0.5.6

Link to section 'Commands' of 'metaseq' Commands

python
python2

Link to section 'Module' of 'metaseq' Module

You can load the modules by:

module load biocontainers
module load metaseq

Link to section 'Example job' of 'metaseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run metaseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=metaseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers metaseq

methyldackel

Link to section 'Introduction' of 'methyldackel' Introduction

MethylDackel (formerly named PileOMeth, which was a temporary name derived due to it using a PILEup to extract METHylation metrics) will process a coordinate-sorted and indexed BAM or CRAM file containing some form of BS-seq alignments and extract per-base methylation metrics from them. MethylDackel requires an indexed fasta file containing the reference genome as well.

BioContainers: https://biocontainers.pro/tools/methyldackel
Home page: https://github.com/dpryan79/MethylDackel

Link to section 'Versions' of 'methyldackel' Versions

0.6.1

Link to section 'Commands' of 'methyldackel' Commands

MethylDackel

Link to section 'Module' of 'methyldackel' Module

You can load the modules by:

module load biocontainers
module load methyldackel

Link to section 'Example job' of 'methyldackel' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run methyldackel on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=methyldackel
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers methyldackel

MethylDackel extract chgchh.fa chgchh_aln.bam

metilene

Link to section 'Introduction' of 'metilene' Introduction

Metilene is a versatile tool to study the effect of epigenetic modifications in differentiation/development, tumorigenesis, and systems biology on a global, genome-wide level.

BioContainers: https://biocontainers.pro/tools/metilene
Home page: https://www.bioinf.uni-leipzig.de/Software/metilene/

Link to section 'Versions' of 'metilene' Versions

0.2.8

Link to section 'Commands' of 'metilene' Commands

metilene
metilene_input.pl
metilene_output.pl
metilene_output.R

Link to section 'Module' of 'metilene' Module

You can load the modules by:

module load biocontainers
module load metilene

Link to section 'Example job' of 'metilene' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run metilene on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=metilene
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers metilene

metilene -a g1 -b g2 methylation-file

mhm2

Link to section 'Introduction' of 'mhm2' Introduction

MetaHipMer is a de novo metagenome short-read assembler. Version 2 (MHM2) is written entirely in UPC++ and runs efficiently on both single servers and on multinode supercomputers, where it can scale up to coassemble terabase-sized metagenomes.

Home page: https://bitbucket.org/berkeleylab/mhm2/wiki/Home.md

Link to section 'Versions' of 'mhm2' Versions

2.0.0

Link to section 'Commands' of 'mhm2' Commands

mhm2.py

Link to section 'Module' of 'mhm2' Module

You can load the modules by:

module load biocontainers
module load mhm2

Link to section 'Example job' of 'mhm2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mhm2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mhm2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mhm2

mhm2.py -r input_1.fastq,input_2.fastq

microbedmm

Link to section 'Introduction' of 'microbedmm' Introduction

MicrobeDMM is a suite of programs used for empirical Bayes fitting of DMM models.

For more information, please check its home page: https://code.google.com/archive/p/microbedmm.

Link to section 'Versions' of 'microbedmm' Versions

Link to section 'Commands' of 'microbedmm' Commands

DirichletMixtureGHPFit

Link to section 'Module' of 'microbedmm' Module

You can load the modules by:

module load biocontainers
module load microbedmm

Link to section 'Example job' of 'microbedmm' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MicrobeDMM on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=microbedmm
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers microbedmm

minialign

Link to section 'Introduction' of 'minialign' Introduction

Minialign is a little bit fast and moderately accurate nucleotide sequence alignment tool designed for PacBio and Nanopore long reads.

For more information, please check its website: https://biocontainers.pro/tools/minialign and its home page on Github.

Link to section 'Versions' of 'minialign' Versions

0.5.3

Link to section 'Commands' of 'minialign' Commands

minialign

Link to section 'Module' of 'minialign' Module

You can load the modules by:

module load biocontainers
module load minialign

Link to section 'Example job' of 'minialign' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Minialign on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=minialign
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers minialign

minialign -d index.mai genome.fasta
minialign -l index.mai input.fastq > out.sam

miniasm

Link to section 'Introduction' of 'miniasm' Introduction

Miniasm is a very fast OLC-based de novo assembler for noisy long reads.

For more information, please check its website: https://biocontainers.pro/tools/miniasm and its home page on Github.

Link to section 'Versions' of 'miniasm' Versions

0.3_r179

Link to section 'Commands' of 'miniasm' Commands

miniasm
minidot

Link to section 'Module' of 'miniasm' Module

You can load the modules by:

module load biocontainers
module load miniasm

Link to section 'Example job' of 'miniasm' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Miniasm on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=miniasm
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers miniasm

miniasm -f Elysia_ont_test.fq  Elysia_reads.paf.gz \
     > Elysia_reads.gfa

minimap2

Link to section 'Introduction' of 'minimap2' Introduction

Minimap2 is a versatile pairwise aligner for genomic and spliced nucleotide sequences.

For more information, please check its website: https://biocontainers.pro/tools/minimap2 and its home page on Github.

Link to section 'Versions' of 'minimap2' Versions

2.22
2.24
2.26

Link to section 'Commands' of 'minimap2' Commands

minimap2
paftools.js
k8

Link to section 'Module' of 'minimap2' Module

You can load the modules by:

module load biocontainers
module load minimap2

Link to section 'Example job' of 'minimap2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Minimap2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=minimap2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers minimap2

minimap2 -ax sr Wuhan-Hu-1.fasta \
    seq_1.fastq seq_2.fastq \
    > aln.sam

minipolish

Link to section 'Introduction' of 'minipolish' Introduction

Minipolish is a tool for Racon polishing of miniasm assemblies.

Docker hub: https://hub.docker.com/r/staphb/minipolish
Home page: https://github.com/rrwick/Minipolish

Link to section 'Versions' of 'minipolish' Versions

0.1.3

Link to section 'Commands' of 'minipolish' Commands

minipolish

Link to section 'Module' of 'minipolish' Module

You can load the modules by:

module load biocontainers
module load minipolish

Link to section 'Example job' of 'minipolish' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run minipolish on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=minipolish
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers minipolish

minipolish -t 8 long_reads.fastq.gz assembly.gfa > polished.gfa

miniprot

Link to section 'Introduction' of 'miniprot' Introduction

Miniprot aligns a protein sequence against a genome with affine gap penalty, splicing and frameshift. It is primarily intended for annotating protein-coding genes in a new species using known genes from other species. Miniprot is similar to GeneWise and Exonerate in functionality but it can map proteins to whole genomes and is much faster at the residue alignment step.

Home page: https://github.com/lh3/miniprot

Link to section 'Versions' of 'miniprot' Versions

Link to section 'Commands' of 'miniprot' Commands

miniprot

Link to section 'Module' of 'miniprot' Module

You can load the modules by:

module load biocontainers
module load miniprot

Link to section 'Example job' of 'miniprot' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run miniprot on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=miniprot
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers miniprot

mirdeep2

Link to section 'Introduction' of 'mirdeep2' Introduction

miRDeep2 discovers active known or novel miRNAs from deep sequencing data (Solexa/Illumina, 454, ...).

For more information, please check its website: https://biocontainers.pro/tools/mirdeep2 and its home page on Github.

Link to section 'Versions' of 'mirdeep2' Versions

2.0.1.3

Link to section 'Module' of 'mirdeep2' Module

You can load the modules by:

module load biocontainers
module load mirdeep2

Link to section 'Example job' of 'mirdeep2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run miRDeep2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mirdeep2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mirdeep2

miRDeep2.pl reads_collapsed.fa genome.fa reads_collapsed_vs_genome.arf \
  miRBase_mmu_v14.fa miRBase_rno_v14.fa precursors_ref_this_species.fa \
  -t Mouse 2>report.log

mirtop

Link to section 'Introduction' of 'mirtop' Introduction

Mirtop is a ommand line tool to annotate with a standard naming miRNAs e isomiRs.

BioContainers: https://biocontainers.pro/tools/mirtop
Home page: https://github.com/miRTop/mirtop

Link to section 'Versions' of 'mirtop' Versions

0.4.25

Link to section 'Commands' of 'mirtop' Commands

mirtop

Link to section 'Module' of 'mirtop' Module

You can load the modules by:

module load biocontainers
module load mirtop

Link to section 'Example job' of 'mirtop' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mirtop on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mirtop
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mirtop

mirtop gff --format prost --sps hsa 
    --hairpin examples/annotate/hairpin.fa \
    --gtf examples/annotate/hsa.gff3 \
    -o test_out \
    examples/prost/prost.example.txt

mitofinder

Link to section 'Introduction' of 'mitofinder' Introduction

Mitofinder is a pipeline to assemble mitochondrial genomes and annotate mitochondrial genes from trimmed read sequencing data.

For more information, please check its website: https://cloud.sylabs.io/library/remiallio/default/mitofinder and its home page on Github.

Link to section 'Versions' of 'mitofinder' Versions

1.4.1

Link to section 'Commands' of 'mitofinder' Commands

mitofinder

Link to section 'Module' of 'mitofinder' Module

You can load the modules by:

module load biocontainers
module load mitofinder

Link to section 'Example job' of 'mitofinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mitofinder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mitofinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mitofinder

mitofinder -j Aphaenogaster_megommata_SRR1303315 \
           -1 Aphaenogaster_megommata_SRR1303315_R1_cleaned.fastq.gz \
           -2 Aphaenogaster_megommata_SRR1303315_R2_cleaned.fastq.gz \
           -r reference.gb -o 5 -p 5 -m 10

mlst

Link to section 'Introduction' of 'mlst' Introduction

Mlst is used to scan contig files against traditional PubMLST typing schemes.

Docker hub: https://hub.docker.com/r/staphb/mlst
Home page: https://github.com/tseemann/mlst

Link to section 'Versions' of 'mlst' Versions

2.22.0
2.23.0

Link to section 'Commands' of 'mlst' Commands

mlst

Link to section 'Module' of 'mlst' Module

You can load the modules by:

module load biocontainers
module load mlst

Link to section 'Example job' of 'mlst' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mlst on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mlst
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mlst

mlst contigs.fa
mlst genome.gbk.gz

mmseqs2

Link to section 'Introduction' of 'mmseqs2' Introduction

Mmseqs2 is a software suite to search and cluster huge protein and nucleotide sequence sets.

For more information, please check its website: https://biocontainers.pro/tools/mmseqs2 and its home page on Github.

Link to section 'Versions' of 'mmseqs2' Versions

13.45111
14.7e284

Link to section 'Commands' of 'mmseqs2' Commands

mmseqs

Link to section 'Module' of 'mmseqs2' Module

You can load the modules by:

module load biocontainers
module load mmseqs2

Link to section 'Example job' of 'mmseqs2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mmseqs2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mmseqs2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mmseqs2

mmseqs createdb examples/DB.fasta targetDB
mmseqs createtaxdb targetDB tmp
mmseqs createindex targetDB tmp
mmseqs easy-taxonomy examples/QUERY.fasta targetDB alnRes tmp

mob_suite

Link to section 'Introduction' of 'mob_suite' Introduction

MOB-suite: Software tools for clustering, reconstruction and typing of plasmids from draft assemblies.

Docker hub: https://hub.docker.com/r/kbessonov/mob_suite
Home page: https://github.com/phac-nml/mob-suite

Link to section 'Versions' of 'mob_suite' Versions

3.0.3

Link to section 'Commands' of 'mob_suite' Commands

mob_cluster
mob_init
mob_recon
mob_typer

Link to section 'Module' of 'mob_suite' Module

You can load the modules by:

module load biocontainers
module load mob_suite

Link to section 'Example job' of 'mob_suite' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mob_suite on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mob_suite
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mob_suite

modbam2bed

Link to section 'Introduction' of 'modbam2bed' Introduction

Modbam2bed is a program to aggregate modified base counts stored in a modified-base BAM file to a bedMethyl file.

Docker hub: https://hub.docker.com/r/zeunas/modbam2bed
Home page: https://github.com/epi2me-labs/modbam2bed

Link to section 'Versions' of 'modbam2bed' Versions

0.9.1

Link to section 'Commands' of 'modbam2bed' Commands

modbam2bed

Link to section 'Module' of 'modbam2bed' Module

You can load the modules by:

module load biocontainers
module load modbam2bed

Link to section 'Example job' of 'modbam2bed' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run modbam2bed on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=modbam2bed
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers modbam2bed

modeltest-ng

Link to section 'Introduction' of 'modeltest-ng' Introduction

ModelTest-NG is a tool for selecting the best-fit model of evolution for DNA and protein alignments. ModelTest-NG supersedes jModelTest and ProtTest in one single tool, with graphical and command console interfaces.

BioContainers: https://biocontainers.pro/tools/modeltest-ng
Home page: https://github.com/ddarriba/modeltest

Link to section 'Versions' of 'modeltest-ng' Versions

0.1.7

Link to section 'Commands' of 'modeltest-ng' Commands

modeltest-ng
modeltest-ng-mpi

Link to section 'Module' of 'modeltest-ng' Module

You can load the modules by:

module load biocontainers
module load modeltest-ng

Link to section 'Example job' of 'modeltest-ng' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run modeltest-ng on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=modeltest-ng
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers modeltest-ng

momi

Link to section 'Introduction' of 'momi' Introduction

momi (MOran Models for Inference) is a Python package that computes the expected sample frequency spectrum (SFS), a statistic commonly used in population genetics, and uses it to fit demographic history.

Home page: https://momi2.readthedocs.io/en/latest/

Link to section 'Versions' of 'momi' Versions

2.1.19

Link to section 'Commands' of 'momi' Commands

python
python3

Link to section 'Module' of 'momi' Module

You can load the modules by:

module load biocontainers
module load momi

Link to section 'Interactive job' of 'momi' Interactive job

To run momi interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers momi
(base) UserID@bell-a008:~ $ python
Python 3.9.7 (default, Sep 16 2021, 13:09:58) 
[GCC 7.5.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import momi
>>> import logging
>>> logging.basicConfig(level=logging.INFO,
                 filename="tutorial.log")
>>> model = momi.DemographicModel(N_e=1.2e4, gen_time=29,
                           muts_per_gen=1.25e-8)

Link to section 'Batch job' of 'momi' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run momi on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=momi
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers momi

python python.py

mothur

Mothur is an open source software package for bioinformatics data processing. The package is frequently used in the analysis of DNA from uncultured microbes.

Detailed information about Mothur can be found here: https://mothur.org

Link to section 'Versions' of 'mothur' Versions

1.46.0
1.47.0
1.48.0

Link to section 'Commands' of 'mothur' Commands

mothur

Link to section 'Module' of 'mothur' Module

You can load the modules by:

module load biocontainers  
module load mothur/1.47.0

Link to section 'Interactive job' of 'mothur' Interactive job

To run mothur interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers mothur/1.47.0 
(base) UserID@bell-a008:~ $ mothur
Linux version

Using ReadLine,Boost,HDF5,GSL
mothur v.1.47.0
Last updated: 1/21/22
by
Patrick D. Schloss

Department of Microbiology & Immunology

University of Michigan
http://www.mothur.org

When using, please cite:
Schloss, P.D., et al., Introducing mothur: Open-source, platform-independent, community-supported software for describing and comparing microbial communities. Appl Environ Microbiol, 2009. 75(23):7537-41.

Distributed under the GNU General Public License

Type 'help()' for information on the commands that are available

For questions and analysis support, please visit our forum at https://forum.mothur.org

Type 'quit()' to exit program

[NOTE]: Setting random seed to 19760620.

Interactive Mode

mothur > align.seqs(help)
mothur > quit()

Link to section 'Batch job' of 'mothur' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=mothur
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mothur/1.47.0 

mothur batch_file

motus

Link to section 'Introduction' of 'motus' Introduction

The mOTU profiler is a computational tool that estimates relative taxonomic abundance of known and currently unknown microbial community members using metagenomic shotgun sequencing data.

Home page: https://github.com/motu-tool/mOTUs

Link to section 'Versions' of 'motus' Versions

3.0.3

Link to section 'Commands' of 'motus' Commands

motus

Link to section 'Module' of 'motus' Module

You can load the modules by:

module load biocontainers
module load motus

Link to section 'Example job' of 'motus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run motus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=motus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers motus

mrbayes

Link to section 'Introduction' of 'mrbayes' Introduction

MrBayes is a program for Bayesian inference and model choice across a wide range of phylogenetic and evolutionary models. MrBayes uses Markov chain Monte Carlo (MCMC) methods to estimate the posterior distribution of model parameters.

MrBayes is available both in a serial version ('mb') and in a parallel version ('mb-mpi') that uses MPI instructions to distribute computations across several processors or processor cores. The serial version does not support multi-threading, which means that you will not be able to utilize more than one core on a multi-core machine for a single MrBayes analysis. If you want to utilize all cores,you need to run the MPI version of MrBayes.

Note: 'mb-mpi' in this version of the container does not run across multiple nodes (only within a node). This is a bug in the container (upstream).

For more information, please check its website: https://biocontainers.pro/tools/mrbayes and its home page: http://mrbayes.net.

Link to section 'Versions' of 'mrbayes' Versions

3.2.7

Link to section 'Commands' of 'mrbayes' Commands

mb
mb-mpi
mpirun
mpiexec

Link to section 'Module' of 'mrbayes' Module

You can load the modules by:

module load biocontainers
module load mrbayes

Link to section 'Example job' of 'mrbayes' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run MrBayes on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mrbayes
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mrbayes

multiqc

Link to section 'Introduction' of 'multiqc' Introduction

Multiqc is a reporting tool that parses summary statistics from results and log files generated by other bioinformatics tools.

For more information, please check its website: https://biocontainers.pro/tools/multiqc and its home page: https://multiqc.info.

Link to section 'Versions' of 'multiqc' Versions

1.11

Link to section 'Commands' of 'multiqc' Commands

multiqc

Link to section 'Module' of 'multiqc' Module

You can load the modules by:

module load biocontainers
module load multiqc

Link to section 'Example job' of 'multiqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Multiqc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=multiqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers multiqc
    
multiqc fastqc_out -o multiqc_out

mummer4

Link to section 'Introduction' of 'mummer4' Introduction

Mummer4 is a versatile alignment tool for DNA and protein sequences.

For more information, please check its website: https://biocontainers.pro/tools/mummer4 and its home page on Github.

Link to section 'Versions' of 'mummer4' Versions

4.0.0rc1-pl5262

Link to section 'Module' of 'mummer4' Module

You can load the modules by:

module load biocontainers
module load mummer4

Link to section 'Example job' of 'mummer4' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Mummer4 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mummer4
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mummer4

mummer -mum -b -c H_pylori26695_Eslice.fasta H_pyloriJ99_Eslice.fasta > mummer.mums

muscle

Link to section 'Introduction' of 'muscle' Introduction

Muscle is a modified progressive alignment algorithm which has comparable accuracy to MAFFT, but faster performance.

For more information, please check its website: https://biocontainers.pro/tools/muscle and its home page: http://www.drive5.com/muscle/muscle_userguide3.8.html.

Link to section 'Versions' of 'muscle' Versions

3.8.1551
5.1

Link to section 'Versions' of 'muscle' Versions

3.8.1551
5.1

Link to section 'Commands' of 'muscle' Commands

muscle

Link to section 'Module' of 'muscle' Module

You can load the modules by:

module load biocontainers
module load muscle

Link to section 'Example job' of 'muscle' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Muscle on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=muscle
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers muscle

muscle -align seqs2.fasta  -output seqs.afa

mutmap

Link to section 'Introduction' of 'mutmap' Introduction

MutMap is a powerful and efficient method to identify agronomically important loci in crop plants.

BioContainers: https://biocontainers.pro/tools/mutmap
Home page: https://github.com/YuSugihara/MutMap#What-is-MutMap

Link to section 'Versions' of 'mutmap' Versions

2.3.3

Link to section 'Commands' of 'mutmap' Commands

mutmap
mutplot

Link to section 'Module' of 'mutmap' Module

You can load the modules by:

module load biocontainers
module load mutmap

Link to section 'Example job' of 'mutmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mutmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mutmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mutmap

mykrobe

Link to section 'Introduction' of 'mykrobe' Introduction

Mykrobe analyses the whole genome of a bacterial sample, all within a couple of minutes, and predicts which drugs the infection is resistant to.

Docker hub: https://hub.docker.com/r/staphb/mykrobe
Home page: https://github.com/Mykrobe-tools/mykrobe

Link to section 'Versions' of 'mykrobe' Versions

0.11.0

Link to section 'Commands' of 'mykrobe' Commands

mykrobe

Link to section 'Module' of 'mykrobe' Module

You can load the modules by:

module load biocontainers
module load mykrobe

Link to section 'Example job' of 'mykrobe' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run mykrobe on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=mykrobe
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers mykrobe

n50

Link to section 'Introduction' of 'n50' Introduction

N50 is a command line tool to calculate assembly metrices.

BioContainers: https://biocontainers.pro/tools/n50
Home page: https://github.com/quadram-institute-bioscience/seqfu/wiki/n50

Link to section 'Versions' of 'n50' Versions

1.5.6

Link to section 'Commands' of 'n50' Commands

Link to section 'Module' of 'n50' Module

You can load the modules by:

module load biocontainers
module load n50

Link to section 'Example job' of 'n50' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run n50 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=n50
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers n50

nanofilt

Link to section 'Introduction' of 'nanofilt' Introduction

Nanofilt is a tool for filtering and trimming of Oxford Nanopore Sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/nanofilt and its home page on Github.

Link to section 'Versions' of 'nanofilt' Versions

2.8.0

Link to section 'Commands' of 'nanofilt' Commands

NanoFilt

Link to section 'Module' of 'nanofilt' Module

You can load the modules by:

module load biocontainers
module load nanofilt

Link to section 'Example job' of 'nanofilt' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nanofilt on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nanofilt
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nanofilt

NanoFilt -q 12 --headcrop 75 reads.fastq |  gzip > trimmed-reads.fastq.gz

nanolyse

Link to section 'Introduction' of 'nanolyse' Introduction

Nanolyse is a tool to remove reads mapping to the lambda phage genome from a fastq file.

For more information, please check its website: https://biocontainers.pro/tools/nanolyse and its home page on Github.

Link to section 'Versions' of 'nanolyse' Versions

1.2.0

Link to section 'Commands' of 'nanolyse' Commands

NanoLyse

Link to section 'Module' of 'nanolyse' Module

You can load the modules by:

module load biocontainers
module load nanolyse

Link to section 'Example job' of 'nanolyse' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nanolyse on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nanolyse
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nanolyse

gunzip -c reads.fastq.gz |  NanoLyse |  gzip > reads_without_lambda.fastq.gz

nanoplot

Link to section 'Introduction' of 'nanoplot' Introduction

Nanoplot is a plotting tool for long read sequencing data and alignments.

For more information, please check its website: https://biocontainers.pro/tools/nanoplot and its home page on Github.

Link to section 'Versions' of 'nanoplot' Versions

1.39.0

Link to section 'Commands' of 'nanoplot' Commands

NanoPlot

Link to section 'Module' of 'nanoplot' Module

You can load the modules by:

module load biocontainers
module load nanoplot

Link to section 'Example job' of 'nanoplot' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nanoplot on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=nanoplot
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nanoplot

NanoPlot --summary sequencing_summary.txt --loglength -o summary-plots-log-transformed  
NanoPlot -t 2 --fastq reads1.fastq.gz reads2.fastq.gz --maxlength 40000 --plots dot --legacy hex
NanoPlot -t 12 --color yellow --bam alignment1.bam alignment2.bam alignment3.bam --downsample 10000 -o bamplots_downsampled

nanopolish

Link to section 'Introduction' of 'nanopolish' Introduction

Nanopolish is a software package for signal-level analysis of Oxford Nanopore sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/nanopolish and its home page on Github.

Link to section 'Versions' of 'nanopolish' Versions

0.13.2
0.14.0

Link to section 'Commands' of 'nanopolish' Commands

nanopolish

Link to section 'Module' of 'nanopolish' Module

You can load the modules by:

module load biocontainers
module load nanopolish

Link to section 'Example job' of 'nanopolish' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nanopolish on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nanopolish
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nanopolish

nanopolish index -d fast5_files/ reads.fasta

nanopolish variants --consensus \
    -o polished.vcf -w "tig00000001:200000-202000" \
     -r reads.fasta -b reads.sorted.bam  -g draft.fa

ncbi-amrfinderplus

Link to section 'Introduction' of 'ncbi-amrfinderplus' Introduction

Ncbi-amrfinderplus and the accompanying database identify acquired antimicrobial resistance genes in bacterial protein and/or assembled nucleotide sequences as well as known resistance-associated point mutations for several taxa.

BioContainers: https://biocontainers.pro/tools/ncbi-amrfinderplus
Home page: https://github.com/ncbi/amr

Link to section 'Versions' of 'ncbi-amrfinderplus' Versions

3.10.30
3.10.42

Link to section 'Commands' of 'ncbi-amrfinderplus' Commands

amrfinder

Link to section 'Module' of 'ncbi-amrfinderplus' Module

You can load the modules by:

module load biocontainers
module load ncbi-amrfinderplus

AMRFinderPlus database has been setup for users. Users can check the database version by amrfinder -V. RCAC will keep updating database for users. If you notice our database is out of date, you can contact us to update the database.

Link to section 'Example job' of 'ncbi-amrfinderplus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ncbi-amrfinderplus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ncbi-amrfinderplus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ncbi-amrfinderplus

# Protein AMRFinder with no genomic coordinates
amrfinder -p test_prot.fa

# Translated nucleotide AMRFinder (will not use HMMs)
amrfinder -n test_dna.fa

# Protein AMRFinder using GFF to get genomic coordinates and 'plus' genes
amrfinder -p test_prot.fa -g test_prot.gff --plus

# Protein AMRFinder with Escherichia protein point mutations
amrfinder -p test_prot.fa -O Escherichia

# Full AMRFinderPlus search combining results
amrfinder -p test_prot.fa -g test_prot.gff -n test_dna.fa -O Escherichia --plus

ncbi-datasets

Link to section 'Introduction' of 'ncbi-datasets' Introduction

NCBI Datasets is a new resource that lets you easily gather data from across NCBI databases. You can use it to find and download sequence, annotation, and metadata for genes and genomes using our command-line interface (CLI) tools or NCBI Datasets web interface.

Docker hub: https://hub.docker.com/r/staphb/ncbi-datasets
Home page: https://github.com/ncbi/datasets

Link to section 'Versions' of 'ncbi-datasets' Versions

14.3.0

Link to section 'Commands' of 'ncbi-datasets' Commands

datasets
dataformat

Link to section 'Module' of 'ncbi-datasets' Module

You can load the modules by:

module load biocontainers
module load ncbi-datasets

Link to section 'Example job' of 'ncbi-datasets' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ncbi-datasets on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ncbi-datasets
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ncbi-datasets

ncbi-genome-download

Link to section 'Introduction' of 'ncbi-genome-download' Introduction

Ncbi-genome-download is a script to download genomes from the NCBI FTP servers.

For more information, please check its website: https://biocontainers.pro/tools/ncbi-genome-download and its home page on Github.

Link to section 'Versions' of 'ncbi-genome-download' Versions

0.3.1

Link to section 'Commands' of 'ncbi-genome-download' Commands

ncbi-genome-download

Link to section 'Module' of 'ncbi-genome-download' Module

You can load the modules by:

module load biocontainers
module load ncbi-genome-download

Link to section 'Example job' of 'ncbi-genome-download' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ncbi-genome-download on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=ncbi-genome-download
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ncbi-genome-download

ncbi-genome-download bacteria,viral --parallel 4
ncbi-genome-download --genera "Streptomyces coelicolor,Escherichia coli" bacteria
ncbi-genome-download --species-taxids 562 bacteria

ncbi-table2asn

Link to section 'Introduction' of 'ncbi-table2asn' Introduction

table2asn is a command-line program that creates sequence records for submission to GenBank. It uses many of the same functions as Genome Workbench but is driven generally by data files, and the records it produces do not necessarily require additional manual editing before submission to GenBank.

Docker hub: https://hub.docker.com/r/staphb/ncbi-table2asn
Home page: https://www.ncbi.nlm.nih.gov/genbank/table2asn/

Link to section 'Versions' of 'ncbi-table2asn' Versions

1.26.678

Link to section 'Commands' of 'ncbi-table2asn' Commands

table2asn

Link to section 'Module' of 'ncbi-table2asn' Module

You can load the modules by:

module load biocontainers
module load ncbi-table2asn

Link to section 'Example job' of 'ncbi-table2asn' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ncbi-table2asn on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ncbi-table2asn
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ncbi-table2asn

neusomatic

Link to section 'Introduction' of 'neusomatic' Introduction

NeuSomatic is based on deep convolutional neural networks for accurate somatic mutation detection. With properly trained models, it can robustly perform across sequencing platforms, strategies, and conditions. NeuSomatic summarizes and augments sequence alignments in a novel way and incorporates multi-dimensional features to capture variant signals effectively. It is not only a universal but also accurate somatic mutation detection method.

Docker hub: https://hub.docker.com/r/msahraeian/neusomatic/
Home page: https://github.com/bioinform/neusomatic

Link to section 'Versions' of 'neusomatic' Versions

0.2.1

Link to section 'Module' of 'neusomatic' Module

You can load the modules by:

module load biocontainers
module load neusomatic

Link to section 'Example job' of 'neusomatic' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run neusomatic on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=neusomatic
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers neusomatic

nextalign

Link to section 'Introduction' of 'nextalign' Introduction

Nextalign is a viral genome sequence alignment tool for command line.

Docker hub: https://hub.docker.com/r/nextstrain/nextalign and its home page: https://docs.nextstrain.org/projects/nextclade/en/stable/user/nextalign-cli.html.

Link to section 'Versions' of 'nextalign' Versions

1.10.3

Link to section 'Commands' of 'nextalign' Commands

nextalign

Link to section 'Module' of 'nextalign' Module

You can load the modules by:

module load biocontainers
module load nextalign

Link to section 'Example job' of 'nextalign' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nextalign on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nextalign
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nextalign

nextalign \
     --sequences data/sars-cov-2/sequences.fasta \
     --reference data/sars-cov-2/reference.fasta \
     --genemap data/sars-cov-2/genemap.gff \
    --genes E,M,N,ORF1a,ORF1b,ORF3a,ORF6,ORF7a,ORF7b,ORF8,ORF9b,S \
    --output-dir output/ \
    --output-basename nextalign

nextclade

Link to section 'Introduction' of 'nextclade' Introduction

Nextclade is a tool that identifies differences between your sequences and a reference sequence, uses these differences to assign your sequences to clades, and reports potential sequence quality issues in your data.

Docker hub: https://hub.docker.com/r/nextstrain/nextclade and its home page: https://docs.nextstrain.org/projects/nextclade/en/stable/user/nextclade-cli.html.

Link to section 'Versions' of 'nextclade' Versions

1.10.3

Link to section 'Commands' of 'nextclade' Commands

nextclade

Link to section 'Module' of 'nextclade' Module

You can load the modules by:

module load biocontainers
module load nextclade

Link to section 'Example job' of 'nextclade' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nextclade on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nextclade
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nextclade

mkdir -p data
nextclade dataset get --name 'sars-cov-2' --output-dir 'data/sars-cov-2'

nextclade \
    --in-order \
    --input-fasta data/sars-cov-2/sequences.fasta \
    --input-dataset data/sars-cov-2 \
    --output-tsv output/nextclade.tsv \
    --output-tree output/nextclade.auspice.json \
    --output-dir output/ \
    --output-basename nextclade

nextflow

Link to section 'Introduction' of 'nextflow' Introduction

Nextflow is a bioinformatics workflow manager that enables the development of portable and reproducible workflows.

For more information, please check its website: https://biocontainers.pro/tools/nextflow and its home page on Github.

Link to section 'Versions' of 'nextflow' Versions

21.10.0

Link to section 'Commands' of 'nextflow' Commands

nextflow

Link to section 'Module' of 'nextflow' Module

You can load the modules by:

module load biocontainers
module load nextflow

Link to section 'Example job' of 'nextflow' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Nextflow on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=nextflow
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers nextflow

ngs-bits

Link to section 'Introduction' of 'ngs-bits' Introduction

Ngs-bits - Short-read sequencing tools.

For more information, please check its website: https://biocontainers.pro/tools/ngs-bits and its home page on Github.

Link to section 'Versions' of 'ngs-bits' Versions

2022_04

Link to section 'Module' of 'ngs-bits' Module

You can load the modules by:

module load biocontainers
module load ngs-bits

Link to section 'Example job' of 'ngs-bits' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ngs-bits on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ngs-bits
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ngs-bits

SeqPurge -in1 input1_1.fastq input2_1.fastq \
     -in2 input2_2.fastq input2_2.fastq \
     -out1 R1.fastq.gz -out2 R2.fastq.gz

ngsld

Link to section 'Introduction' of 'ngsld' Introduction

ngsLD is a program to estimate pairwise linkage disequilibrium (LD) taking the uncertainty of genotype's assignation into account. It does so by avoiding genotype calling and using genotype likelihoods or posterior probabilities.

Home page: https://github.com/fgvieira/ngsLD

Link to section 'Versions' of 'ngsld' Versions

1.1.1

Link to section 'Commands' of 'ngsld' Commands

ngsLD

Link to section 'Module' of 'ngsld' Module

You can load the modules by:

module load biocontainers
module load ngsld

Link to section 'Example job' of 'ngsld' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ngsld on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ngsld
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ngsld

ngsutils

Link to section 'Introduction' of 'ngsutils' Introduction

Ngsutils is a suite of software tools for working with next-generation sequencing datasets.

For more information, please check its website: https://biocontainers.pro/tools/ngsutils and its home page: http://ngsutils.org.

Link to section 'Versions' of 'ngsutils' Versions

0.5.9

Link to section 'Commands' of 'ngsutils' Commands

ngsutils
bamutils
bedutils
fastqutils
gtfutils

Link to section 'Module' of 'ngsutils' Module

You can load the modules by:

module load biocontainers
module load ngsutils

Link to section 'Example job' of 'ngsutils' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ngsutils on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ngsutils
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ngsutils

bamutils filter \
    input.bam \
    MQ10filtered.bam  \
    -mapped \
    -noqcfail \
    -gte MAPQ 10

bamutils stats \
   -gtf genome.gtf MQ10filtered.bam \ 
   > MQ10filtered_bamstats

orthofinder

OrthoFinder: phylogenetic orthology inference for comparative genomics

Detailed usage can be found here: https://github.com/davidemms/OrthoFinder

Link to section 'Versions' of 'orthofinder' Versions

2.5.2
2.5.4

Link to section 'Commands' of 'orthofinder' Commands

orthofinder

Link to section 'Module' of 'orthofinder' Module

You can load the modules by:

module load biocontainers
module load orthofinder/2.5.4

Link to section 'Example job' of 'orthofinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run orthofinder on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=orthofinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers orthofinder/2.5.4

orthofinder -t 24 -f InputData -o output

paml

Link to section 'Introduction' of 'paml' Introduction

Paml is a package of programs for phylogenetic analyses of DNA or protein sequences using maximum likelihood.

For more information, please check its website: https://biocontainers.pro/tools/paml and its home page: http://abacus.gene.ucl.ac.uk/software/paml.html.

Link to section 'Versions' of 'paml' Versions

Link to section 'Module' of 'paml' Module

You can load the modules by:

module load biocontainers
module load paml

Link to section 'Example job' of 'paml' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Paml on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=paml
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers paml

panacota

Link to section 'Introduction' of 'panacota' Introduction

Panacota is a software providing tools for large scale bacterial comparative genomics.

For more information, please check its website: https://biocontainers.pro/tools/panacota and its home page on Github.

Link to section 'Versions' of 'panacota' Versions

1.3.1

Link to section 'Commands' of 'panacota' Commands

PanACoTA

Link to section 'Module' of 'panacota' Module

You can load the modules by:

module load biocontainers
module load panacota

Link to section 'Example job' of 'panacota' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Panacota on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=panacota
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers panacota

PanACoTA annotate \
    -d Examples/genomes_init \
    -l Examples/input_files/list_genomes.lst \
    -r Examples/2-res-QC -Q

panaroo

Link to section 'Introduction' of 'panaroo' Introduction

Panaroo is an updated pipeline for pangenome investigation.

BioContainers: https://biocontainers.pro/tools/panaroo
Home page: https://github.com/gtonkinhill/panaroo

Link to section 'Versions' of 'panaroo' Versions

1.2.10

Link to section 'Module' of 'panaroo' Module

You can load the modules by:

module load biocontainers
module load panaroo

Link to section 'Example job' of 'panaroo' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run panaroo on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=panaroo
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers panaroo

panaroo -i gff/*.gff -o results --clean-mode strict

pandaseq

Link to section 'Introduction' of 'pandaseq' Introduction

Pandaseq is a program to align Illumina reads, optionally with PCR primers embedded in the sequence, and reconstruct an overlapping sequence.

Docker hub: https://hub.docker.com/r/pipecraft/pandaseq and its home page on Github.

Link to section 'Versions' of 'pandaseq' Versions

2.11

Link to section 'Commands' of 'pandaseq' Commands

pandaseq

Link to section 'Module' of 'pandaseq' Module

You can load the modules by:

module load biocontainers
module load pandaseq

Link to section 'Example job' of 'pandaseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pandaseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pandaseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pandaseq

pandaseq -f SRR069027_1.fastq -r SRR069027_2.fastq

pandora

Link to section 'Introduction' of 'pandora' Introduction

Pandora is a tool for bacterial genome analysis using a pangenome reference graph (PanRG). It allows gene presence/absence detection and genotyping of SNPs, indels and longer variants in one or a number of samples.

BioContainers: https://biocontainers.pro/tools/pandora
Home page: https://github.com/rmcolq/pandora

Link to section 'Versions' of 'pandora' Versions

0.9.1

Link to section 'Commands' of 'pandora' Commands

pandora

Link to section 'Module' of 'pandora' Module

You can load the modules by:

module load biocontainers
module load pandora

Link to section 'Example job' of 'pandora' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pandora on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=pandora
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pandora

pandora index -t 4 GC00006032.fa

pangolin

Link to section 'Introduction' of 'pangolin' Introduction

Pangolin is a software package for assigning SARS-CoV-2 genome sequences to global lineages.

For more information, please check its website: https://biocontainers.pro/tools/pangolin and its home page on Github.

Link to section 'Versions' of 'pangolin' Versions

3.1.20
4.0.6
4.1.2
4.1.3
4.2

Link to section 'Commands' of 'pangolin' Commands

pangolin

Link to section 'Module' of 'pangolin' Module

You can load the modules by:

module load biocontainers
module load pangolin

Link to section 'Example job' of 'pangolin' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pangolin on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pangolin
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pangolin

panphlan

Link to section 'Introduction' of 'panphlan' Introduction

PanPhlAn (Pangenome-based Phylogenomic Analysis) is a strain-level metagenomic profiling tool for identifying the gene composition and in-vivo transcriptional activity of individual strains in metagenomic samples.

For more information, please check its home page: http://segatalab.cibio.unitn.it/tools/panphlan/.

Link to section 'Versions' of 'panphlan' Versions

Link to section 'Commands' of 'panphlan' Commands

panphlan_download_pangenome.py
panphlan_map.py
panphlan_profiling.py

Link to section 'Module' of 'panphlan' Module

You can load the modules by:

module load biocontainers
module load panphlan

Link to section 'Example job' of 'panphlan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run PanPhlAn on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=panphlan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers panphlan

parabricks

Link to section 'Introduction' of 'parabricks' Introduction

NVIDIA's Clara Parabricks brings next generation sequencing to GPUs, accelerating an array of gold-standard tooling such as BWA-MEM, GATK4, Google's DeepVariant, and many more. Users can achieve a 30-60x acceleration and 99.99% accuracy for variant calling when comparing against CPU-only BWA-GATK4 pipelines, meaning a single server can process up to 60 whole genomes per day. These tools can be easily integrated into current pipelines with drop-in replacement commands to quickly bring speed and data-center scale to a range of applications including germline, somatic and RNA workflows.

NGC Container: https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/clara-parabricks Home page: https://docs.nvidia.com/clara/

Link to section 'Versions' of 'parabricks' Versions

4.0.0-1

Link to section 'Commands' of 'parabricks' Commands

pbrun

Link to section 'Module' of 'parabricks' Module

You can load the modules by:

module load biocontainers
module load parabricks

Link to section 'Example job' of 'parabricks' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

As Clara Parabricks depends on Nvidia GPU, it is only deployed in Scholar, Gilbreth, and ACCESS Anvil.

To run Clara Parabricks on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --gpus=1
#SBATCH --job-name=parabricks
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers parabricks

pbrun haplotypecaller \
  --ref  FVZG01.1.fsa_nt \
  --in-bam output.bam \
  --out-variants variants.vcf

parallel-fastq-dump

Link to section 'Introduction' of 'parallel-fastq-dump' Introduction

Parallel-fastq-dump is the parallel fastq-dump wrapper.

For more information, please check its website: https://biocontainers.pro/tools/parallel-fastq-dump and its home page on Github.

Link to section 'Versions' of 'parallel-fastq-dump' Versions

0.6.7

Link to section 'Commands' of 'parallel-fastq-dump' Commands

parallel-fastq-dump

Link to section 'Module' of 'parallel-fastq-dump' Module

You can load the modules by:

module load biocontainers
module load parallel-fastq-dump

Link to section 'Example job' of 'parallel-fastq-dump' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Parallel-fastq-dump on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=parallel-fastq-dump
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers parallel-fastq-dump

parallel-fastq-dump -s SRR11941281/SRR11941281.sra \ 
    --split-files --threads 4 --gzip

parliament2

Link to section 'Introduction' of 'parliament2' Introduction

Parliament2 identifies structural variants in a given sample relative to a reference genome. These structural variants cover large deletion events that are called as Deletions of a region, Insertions of a sequence into a region, Duplications of a region, Inversions of a region, or Translocations between two regions in the genome.

Docker hub: https://hub.docker.com/r/dnanexus/parliament2
Home page: https://github.com/fritzsedlazeck/parliament2

Link to section 'Versions' of 'parliament2' Versions

0.1.11

Link to section 'Commands' of 'parliament2' Commands

parliament2.py

Link to section 'Module' of 'parliament2' Module

You can load the modules by:

module load biocontainers
module load parliament2

Link to section 'Example job' of 'parliament2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run parliament2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=parliament2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers parliament2

parsnp

Link to section 'Introduction' of 'parsnp' Introduction

Parsnp is used to align the core genome of hundreds to thousands of bacterial genomes within a few minutes to few hours.

For more information, please check its website: https://biocontainers.pro/tools/parsnp and its home page on Github.

Link to section 'Versions' of 'parsnp' Versions

1.6.2

Link to section 'Commands' of 'parsnp' Commands

parsnp

Link to section 'Module' of 'parsnp' Module

You can load the modules by:

module load biocontainers
module load parsnp

Link to section 'Example job' of 'parsnp' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Parsnp on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=parsnp
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers parsnp

parsnp -g examples/mers_virus/ref/England1.gbk \
     -d examples/mers_virus/genomes/*.fna -c -p 8

pasta

Link to section 'Introduction' of 'pasta' Introduction

PASTA: Ultra-Large Multiple Sequence Alignment for Nucleotide and Amino-Acid Sequences.

BioContainers: https://biocontainers.pro/tools/pasta
Home page: https://github.com/smirarab/pasta

Link to section 'Versions' of 'pasta' Versions

1.8.7

Link to section 'Commands' of 'pasta' Commands

run_pasta.py
run_seqtools.py
sumlabels.py
sumtrees.py

Link to section 'Module' of 'pasta' Module

You can load the modules by:

module load biocontainers
module load pasta

Link to section 'Example job' of 'pasta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pasta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pasta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pasta

pbmm2

Link to section 'Introduction' of 'pbmm2' Introduction

Pbmm2 is a minimap2 frontend for PacBio native data formats.

For more information, please check its website: https://biocontainers.pro/tools/pbmm2 and its home page on Github.

Link to section 'Versions' of 'pbmm2' Versions

1.7.0

Link to section 'Commands' of 'pbmm2' Commands

pbmm2

Link to section 'Module' of 'pbmm2' Module

You can load the modules by:

module load biocontainers
module load pbmm2

Link to section 'Example job' of 'pbmm2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pbmm2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=pbmm2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pbmm2

pbmm2 --version

pbmm2 align hg38.fa \
    alz.polished.hq.bam alz.aligned.bam \
     -j 12 --preset ISOSEQ --sort \
     --log-level INFO

pbptyper

Link to section 'Introduction' of 'pbptyper' Introduction

pbptyper is a tool to identify the Penicillin Binding Protein (PBP) of Streptococcus pneumoniae assemblies.

Docker hub: https://hub.docker.com/r/staphb/pbptyper
Home page: https://github.com/rpetit3/pbptyper

Link to section 'Versions' of 'pbptyper' Versions

1.0.4

Link to section 'Commands' of 'pbptyper' Commands

pbptyper

Link to section 'Module' of 'pbptyper' Module

You can load the modules by:

module load biocontainers
module load pbptyper

Link to section 'Example job' of 'pbptyper' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pbptyper on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pbptyper
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pbptyper

pbptyper --assembly test/SRR2912551.fna.gz --outdir output

pcangsd

Link to section 'Introduction' of 'pcangsd' Introduction

PCAngsd is a program that estimates the covariance matrix and individual allele frequencies for low-depth next-generation sequencing (NGS) data in structured/heterogeneous populations using principal component analysis (PCA) to perform multiple population genetic analyses using genotype likelihoods.

For more information, please check its home page on Github.

Link to section 'Versions' of 'pcangsd' Versions

1.10

Link to section 'Commands' of 'pcangsd' Commands

pcangsd

Link to section 'Module' of 'pcangsd' Module

You can load the modules by:

module load biocontainers
module load pcangsd

Link to section 'Example job' of 'pcangsd' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run PCAngsd on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=pcangsd
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pcangsd

pcangsd -b pupfish.beagle.gz --inbreedSites \
     --selection -o pup_pca2 --threads 12

peakranger

Link to section 'Introduction' of 'peakranger' Introduction

Peakranger is a multi-purpose software suite for analyzing next-generation sequencing (NGS) data.

For more information, please check its website: https://biocontainers.pro/tools/peakranger and its home page: http://ranger.sourceforge.net.

Link to section 'Versions' of 'peakranger' Versions

1.18

Link to section 'Commands' of 'peakranger' Commands

peakranger

Link to section 'Module' of 'peakranger' Module

You can load the modules by:

module load biocontainers
module load peakranger

Link to section 'Example job' of 'peakranger' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Peakranger on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=peakranger
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers peakranger

peakranger ccat --format bam  27-1_sorted_MDRD_MQ30filtered.bam 27-4_sorted_MDRD_MQ30filtered.bam \
     ccat_result_with_HTML_report_5kb_region --report \
     --gene_annot_file refGene.txt --plot_region 10000

pepper_deepvariant

Link to section 'Introduction' of 'pepper_deepvariant' Introduction

PEPPER is a genome inference module based on recurrent neural networks that enables long-read variant calling and nanopore assembly polishing in the PEPPER-Margin-DeepVariant pipeline. This pipeline enables nanopore-based variant calling with DeepVariant.

Docker hub: https://hub.docker.com/r/kishwars/pepper_deepvariant
Home page: https://github.com/kishwarshafin/pepper

Link to section 'Versions' of 'pepper_deepvariant' Versions

r0.4.1

Link to section 'Commands' of 'pepper_deepvariant' Commands

run_pepper_margin_deepvariant

Link to section 'Module' of 'pepper_deepvariant' Module

You can load the modules by:

module load biocontainers
module load pepper_deepvariant

Link to section 'Example job' of 'pepper_deepvariant' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pepper_deepvariant on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 32
#SBATCH --job-name=pepper_deepvariant
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pepper_deepvariant

BASE=$PWD

# Set up input data
INPUT_DIR="${BASE}/input/data"
REF="GRCh38_no_alt.chr20.fa"
BAM="HG002_ONT_2_GRCh38.chr20.quickstart.bam"

# Set the number of CPUs to use
THREADS=32

# Set up output directory
OUTPUT_DIR="${BASE}/output"
OUTPUT_PREFIX="HG002_ONT_2_GRCh38_PEPPER_Margin_DeepVariant.chr20"
OUTPUT_VCF="HG002_ONT_2_GRCh38_PEPPER_Margin_DeepVariant.chr20.vcf.gz"
TRUTH_VCF="HG002_GRCh38_1_22_v4.2.1_benchmark.quickstart.vcf.gz"
TRUTH_BED="HG002_GRCh38_1_22_v4.2.1_benchmark_noinconsistent.quickstart.bed"

# Create local directory structure
mkdir -p "${OUTPUT_DIR}"
mkdir -p "${INPUT_DIR}"

# Download the data to input directory
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/HG002_ONT_2_GRCh38.chr20.quickstart.bam
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/HG002_ONT_2_GRCh38.chr20.quickstart.bam.bai
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/GRCh38_no_alt.chr20.fa
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/GRCh38_no_alt.chr20.fa.fai
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/HG002_GRCh38_1_22_v4.2.1_benchmark.quickstart.vcf.gz
wget -P ${INPUT_DIR} https://storage.googleapis.com/pepper-deepvariant-public/quickstart_data/HG002_GRCh38_1_22_v4.2.1_benchmark_noinconsistent.quickstart.bed

run_pepper_margin_deepvariant call_variant \
    -b input/data/HG002_ONT_2_GRCh38.chr20.quickstart.bam \
    -f input/data/GRCh38_no_alt.chr20.fa -o output \
    -p HG002_ONT_2_GRCh38_PEPPER_Margin_DeepVariant.chr20 \
    -t 32 -r chr20:1000000-1020000 \
    --ont_r9_guppy5_sup --ont

perl-bioperl

Link to section 'Introduction' of 'perl-bioperl' Introduction

BioPerl is a collection of Perl modules that facilitate the development of Perl scripts for bioinformatics applications. It provides software modules for many of the typical tasks of bioinformatics programming.

For more information, please check its website: https://biocontainers.pro/tools/perl-bioperl.

Link to section 'Versions' of 'perl-bioperl' Versions

1.7.2-pl526

Link to section 'Module' of 'perl-bioperl' Module

You can load the modules by:

module load biocontainers
module load perl-bioperl

Link to section 'Example job' of 'perl-bioperl' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run BioPerl on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=perl-bioperl
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers perl-bioperl

phast

Link to section 'Introduction' of 'phast' Introduction

PHAST is a freely available software package for comparative and evolutionary genomics. For more information, please check: BioContainers: https://biocontainers.pro/tools/phast
Home page: http://compgen.cshl.edu/phast/

Link to section 'Versions' of 'phast' Versions

Link to section 'Module' of 'phast' Module

You can load the modules by:

module load biocontainers
module load phast

Link to section 'Example job' of 'phast' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phast on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phast

phd2fasta

Link to section 'Introduction' of 'phd2fasta' Introduction

Phd2fasta is a tool to convert Phred ‘phd’ format files to ‘fasta’ format.

For more information, please check its home page: http://www.phrap.org/phredphrapconsed.html.

Link to section 'Versions' of 'phd2fasta' Versions

0.990622

Link to section 'Commands' of 'phd2fasta' Commands

phd2fasta

Link to section 'Module' of 'phd2fasta' Module

You can load the modules by:

module load biocontainers
module load phd2fasta

Link to section 'Example job' of 'phd2fasta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Phd2fasta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phd2fasta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phd2fasta

phg

Link to section 'Introduction' of 'phg' Introduction

Practical Haplotype Graph (PHG) is a general, graph-based, computational framework that can be used with a variety of skim sequencing methods to infer high-density genotypes directly from low-coverage sequence.

Docker hub: https://hub.docker.com/r/maizegenetics/phg
Home page: https://www.maizegenetics.net/phg

Link to section 'Versions' of 'phg' Versions

Link to section 'Module' of 'phg' Module

You can load the modules by:

module load biocontainers
module load phg

Link to section 'Example job' of 'phg' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phg on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phg
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phg

phipack

Link to section 'Introduction' of 'phipack' Introduction

PhiPack: PHI test and other tests of recombination

BioContainers: https://biocontainers.pro/tools/phipack
Home page: http://www.maths.otago.ac.nz/~dbryant/software.html

Link to section 'Versions' of 'phipack' Versions

Link to section 'Commands' of 'phipack' Commands

Phi
Profile

Link to section 'Module' of 'phipack' Module

You can load the modules by:

module load biocontainers
module load phipack

Link to section 'Example job' of 'phipack' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phipack on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phipack
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phipack

phrap

Link to section 'Introduction' of 'phrap' Introduction

phrap is a program for assembling shotgun DNA sequence data.

For more information, please check its home page: http://www.phrap.org/phredphrapconsed.html#block_phrap.

Link to section 'Versions' of 'phrap' Versions

1.090518

Link to section 'Commands' of 'phrap' Commands

phrap

Link to section 'Module' of 'phrap' Module

You can load the modules by:

module load biocontainers
module load phrap

Link to section 'Example job' of 'phrap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phrap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phrap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phrap

phred

Link to section 'Introduction' of 'phred' Introduction

phred software reads DNA sequencing trace files, calls bases, and assigns a quality value to each called base.

For more information, please check its home page: http://www.phrap.org/phredphrapconsed.html#block_phred.

Link to section 'Versions' of 'phred' Versions

0.071220.c

Link to section 'Commands' of 'phred' Commands

phred

Link to section 'Module' of 'phred' Module

You can load the modules by:

module load biocontainers
module load phred

Link to section 'Example job' of 'phred' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phred on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phred
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phred

phylosuite

Link to section 'Introduction' of 'phylosuite' Introduction

PhyloSuite is an integrated and scalable desktop platform for streamlined molecular sequence data management and evolutionary phylogenetics studies.

Docker hub: https://hub.docker.com/r/dongzhang0725/phylosuite
Home page: https://github.com/dongzhang0725/PhyloSuite

Link to section 'Versions' of 'phylosuite' Versions

1.2.3

Link to section 'Commands' of 'phylosuite' Commands

PhyloSuite.sh

Link to section 'Module' of 'phylosuite' Module

You can load the modules by:

module load biocontainers
module load phylosuite

Link to section 'Example job' of 'phylosuite' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run phylosuite on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=phylosuite
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers phylosuite

picard

Picard is a set of command line tools for manipulating high-throughput sequencing (HTS) data and formats such as SAM/BAM/CRAM and VCF.
Detailed usage can be found here: https://broadinstitute.github.io/picard/

Link to section 'Versions' of 'picard' Versions

2.25.1
2.26.10

Link to section 'Commands' of 'picard' Commands

picard

Link to section 'Module' of 'picard' Module

You can load the modules by:

module load biocontainers
module load picard/2.26.10

Link to section 'Example job' of 'picard' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run picard our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=picard
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers picard/2.26.10 

picard MarkDuplicates -Xmx64g I=19P0126636WES_sorted.bam O=19P0126636WES_sorted_md.bam M=19P0126636WES.sorted.markdup.txt REMOVE_DUPLICATES=true
picard BuildBamIndex -Xmx64g I=19P0126636WES_sorted_md.bam
picard CreateSequenceDictionary -R hg38.fa -O hg38.dict

picrust2

Link to section 'Introduction' of 'picrust2' Introduction

Picrust2 is a software for predicting functional abundances based only on marker gene sequences.

For more information, please check its website: https://biocontainers.pro/tools/picrust2 and its home page on Github.

Link to section 'Versions' of 'picrust2' Versions

2.4.2
2.5.0

Link to section 'Module' of 'picrust2' Module

You can load the modules by:

module load biocontainers
module load picrust2

Link to section 'Example job' of 'picrust2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Picrust2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 10
#SBATCH --job-name=picrust2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers picrust2


place_seqs.py -s ../seqs.fna -o out.tre -p 10 \
          --intermediate intermediate/place_seqs

hsp.py -i 16S -t out.tre -o marker_predicted_and_nsti.tsv.gz -p 10 -n

hsp.py -i EC -t out.tre -o EC_predicted.tsv.gz -p 10

metagenome_pipeline.py -i ../table.biom -m marker_predicted_and_nsti.tsv.gz -f EC_predicted.tsv.gz -o EC_metagenome_out --strat_out 

convert_table.py EC_metagenome_out/pred_metagenome_contrib.tsv.gz \
             -c contrib_to_legacy \
             -o EC_metagenome_out/pred_metagenome_contrib.legacy.tsv.gz

pathway_pipeline.py -i EC_metagenome_out/pred_metagenome_contrib.tsv.gz \
                -o pathways_out -p 10

add_descriptions.py -i EC_metagenome_out/pred_metagenome_unstrat.tsv.gz -m EC \
                -o EC_metagenome_out/pred_metagenome_unstrat_descrip.tsv.gz


add_descriptions.py -i pathways_out/path_abun_unstrat.tsv.gz -m METACYC \
                -o pathways_out/path_abun_unstrat_descrip.tsv.gz

picrust2_pipeline.py -s chemerin_16S/seqs.fna -i chemerin_16S/table.biom \
    -o picrust2_out_pipeline -p 10

pilon

Link to section 'Introduction' of 'pilon' Introduction

Pilon is an automated genome assembly improvement and variant detection tool.

For more information, please check its website: https://biocontainers.pro/tools/pilon and its home page on Github.

Link to section 'Versions' of 'pilon' Versions

1.24

Link to section 'Commands' of 'pilon' Commands

pilon.jar

Link to section 'Module' of 'pilon' Module

You can load the modules by:

module load biocontainers
module load pilon

Link to section 'Example job' of 'pilon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pilon on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=pilon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pilon

pilon.jar --nostrays \
     --genome scaffolds.fasta \
     --frags out_sorted.bam \
     --vcf --verbose --threads 12 \
     --output pilon_corrected \
     --outdir pilon_outdir

pindel

Link to section 'Introduction' of 'pindel' Introduction

Pindel is used to detect breakpoints of large deletions, medium sized insertions, inversions, tandem duplications and other structural variants at single-based resolution from next-gen sequence data.

For more information, please check its website: https://biocontainers.pro/tools/pindel and its home page: http://gmt.genome.wustl.edu/packages/pindel/index.html.

Link to section 'Versions' of 'pindel' Versions

0.2.5b9

Link to section 'Commands' of 'pindel' Commands

pindel
pindel2cvf

Link to section 'Module' of 'pindel' Module

You can load the modules by:

module load biocontainers
module load pindel

Link to section 'Example job' of 'pindel' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pindel on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pindel
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pindel

pindel -i simulated_config.txt -f simulated_reference.fa -o bamtest -c ALL

pindel -p COLO-829_20-p_ok.txt -f hs_ref_chr20.fa -o colontumor -c 20

pindel2vcf -r hs_ref_chr20.fa -R HUMAN_G1K_V2 -d 20100101 -p colontumor_D -e 5

pirate

Link to section 'Introduction' of 'pirate' Introduction

Pirate is a pangenome analysis and threshold evaluation toolbox.

For more information, please check its website: https://biocontainers.pro/tools/pirate and its home page on Github.

Link to section 'Versions' of 'pirate' Versions

1.0.4

Link to section 'Module' of 'pirate' Module

You can load the modules by:

module load biocontainers
module load pirate

Link to section 'Example job' of 'pirate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pirate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pirate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pirate

piscem

Link to section 'Introduction' of 'piscem' Introduction

piscem is a rust wrapper for a next-generation index + mapper tool (still currently written in C++17).

BioContainers: https://biocontainers.pro/tools/piscem
Home page: https://github.com/COMBINE-lab/piscem

Link to section 'Versions' of 'piscem' Versions

0.4.3

Link to section 'Commands' of 'piscem' Commands

piscem

Link to section 'Module' of 'piscem' Module

You can load the modules by:

module load biocontainers
module load piscem

Link to section 'Example job' of 'piscem' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run piscem on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=piscem
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers piscem

pixy

Link to section 'Introduction' of 'pixy' Introduction

pixy is a command-line tool for painlessly estimating average nucleotide diversity within (π) and between (dxy) populations from a VCF.

Home page: https://github.com/ksamuk/pixy

Link to section 'Versions' of 'pixy' Versions

1.2.7

Link to section 'Commands' of 'pixy' Commands

pixy

Link to section 'Module' of 'pixy' Module

You can load the modules by:

module load biocontainers
module load pixy

Link to section 'Example job' of 'pixy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pixy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pixy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pixy

plasmidfinder

Link to section 'Introduction' of 'plasmidfinder' Introduction

PlasmidFinder identifies plasmids in total or partial sequenced isolates of bacteria.

Docker hub: https://hub.docker.com/r/staphb/plasmidfinder
Home page: https://bitbucket.org/genomicepidemiology/plasmidfinder/src/master/

Link to section 'Versions' of 'plasmidfinder' Versions

2.1.6

Link to section 'Commands' of 'plasmidfinder' Commands

plasmidfinder.py

Link to section 'Module' of 'plasmidfinder' Module

You can load the modules by:

module load biocontainers
module load plasmidfinder

Link to section 'Example job' of 'plasmidfinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run plasmidfinder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=plasmidfinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers plasmidfinder

plasmidfinder.py -p test/database \
    -i test/test.fsa -o output -mp blastn -x -q

platon

Link to section 'Introduction' of 'platon' Introduction

Platon: identification and characterization of bacterial plasmid contigs from short-read draft assemblies.

BioContainers: https://biocontainers.pro/tools/platon
Home page: https://github.com/oschwengers/platon

Link to section 'Versions' of 'platon' Versions

Link to section 'Commands' of 'platon' Commands

platon

Link to section 'Module' of 'platon' Module

You can load the modules by:

module load biocontainers
module load platon

The environment variable PLATON_DB is set as /depot/itap/datasets/platon/db. This directory contains the required database.

Link to section 'Example job' of 'platon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run platon on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=platon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers platon

platon --verbose --threads 4 contigs.fasta

getorganelle

Link to section 'Introduction' of 'getorganelle' Introduction

GetOrganelle is a fast and versatile toolkit for accurate de novo assembly of organelle genomes.

For more information, please check its website: https://biocontainers.pro/tools/getorganelle and its home page on https://github.com/Kinggerm/GetOrganelle.

Link to section 'Versions' of 'getorganelle' Versions

1.7.7.0

Link to section 'Commands' of 'getorganelle' Commands

get_organelle_config.py
get_organelle_from_assembly.py
get_organelle_from_reads.py
slim_graph.py
summary_get_organelle_output.py

Link to section 'Module' of 'getorganelle' Module

You can load the modules by:

module load biocontainers
module load getorganelle

Link to section 'Example job' of 'getorganelle' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run GetOrganelle on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=getorganelle
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers getorganelle

get_organelle_config.py --add embplant_pt,embplant_mt 
get_organelle_from_reads.py -1 Arabidopsis_simulated.1.fq.gz  \ 
   -2 Arabidopsis_simulated.2.fq.gz -t 1 -o Arabidopsis_simulated.plastome  \
   -F embplant_pt -R 10

platypus

Link to section 'Introduction' of 'platypus' Introduction

Platypus is a tool designed for efficient and accurate variant-detection in high-throughput sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/platypus

Link to section 'Versions' of 'platypus' Versions

0.8.1

Link to section 'Commands' of 'platypus' Commands

platypus

Link to section 'Module' of 'platypus' Module

You can load the modules by:

module load biocontainers
module load platypus

Link to section 'Example job' of 'platypus' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Platypus on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=platypus
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers platypus

plink

Link to section 'Introduction' of 'plink' Introduction

Plink is a free, open-source whole genome association analysis toolset, designed to perform a range of basic, large-scale analyses in a computationally efficient manner.

For more information, please check its website: https://biocontainers.pro/tools/plink and its home page: https://zzz.bwh.harvard.edu/plink/.

Link to section 'Versions' of 'plink' Versions

1.90b6.21

Link to section 'Commands' of 'plink' Commands

plink
prettify

Link to section 'Module' of 'plink' Module

You can load the modules by:

module load biocontainers
module load plink

Link to section 'Example job' of 'plink' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Plink on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=plink
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers plink

plink --file toy --freq --out toy_analysis

plink2

Link to section 'Introduction' of 'plink2' Introduction

Plink2 is a whole genome association analysis toolset.

For more information, please check its website: https://biocontainers.pro/tools/plink2 and its home page on Github.

Link to section 'Versions' of 'plink2' Versions

2.00a2.3

Link to section 'Commands' of 'plink2' Commands

plink2

Link to section 'Module' of 'plink2' Module

You can load the modules by:

module load biocontainers
module load plink2

Link to section 'Example job' of 'plink2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Plink2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=plink2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers plink2

plink2 --bfile HapMap_3_r3_1 --freq --out HapMap_3_r3_1_out

plotsr

Link to section 'Introduction' of 'plotsr' Introduction

Plotsr generates high-quality visualisation of synteny and structural rearrangements between multiple genomes. For this, it uses the genomic structural annotations between multiple chromosome-level assemblies.

Home page: https://github.com/schneebergerlab/plotsr

Link to section 'Versions' of 'plotsr' Versions

0.5.4

Link to section 'Commands' of 'plotsr' Commands

plotsr

Link to section 'Module' of 'plotsr' Module

You can load the modules by:

module load biocontainers
module load plotsr

Link to section 'Example job' of 'plotsr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run plotsr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=plotsr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers plotsr

plotsr syri.out refgenome qrygenome -H 8 -W 5

pomoxis

Link to section 'Introduction' of 'pomoxis' Introduction

Pomoxis comprises a set of basic bioinformatic tools tailored to nanopore sequencing. Notably tools are included for generating and analyzing draft assemblies. Many of these tools are used by the research data analysis group at Oxford Nanopore Technologies.

Docker hub: https://hub.docker.com/r/zeunas/pomoxis
Home page: https://github.com/nanoporetech/pomoxis

Link to section 'Versions' of 'pomoxis' Versions

0.3.9

Link to section 'Module' of 'pomoxis' Module

You can load the modules by:

module load biocontainers
module load pomoxis

Link to section 'Example job' of 'pomoxis' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pomoxis on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=pomoxis
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pomoxis

assess_assembly \
    -i helen_output/Staph_Aur_draft_helen.fa \
    -r truth_assembly_staph_aur.fasta \
    -p polished_assembly_quality \
    -l 50 \
    -t 4 \
    -e \
    -T

poppunk

Link to section 'Introduction' of 'poppunk' Introduction

PopPUNK is a tool for clustering genomes. We refer to the clusters as variable-length-k-mer clusters, or VLKCs. Biologically, these clusters typically represent distinct strains. We refer to subclusters of strains as lineages.

Docker hub: https://hub.docker.com/r/staphb/poppunk
Home page: https://github.com/bacpop/PopPUNK

Link to section 'Versions' of 'poppunk' Versions

2.5.0
2.6.0

Link to section 'Module' of 'poppunk' Module

You can load the modules by:

module load biocontainers
module load poppunk

Link to section 'Example job' of 'poppunk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run poppunk on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=poppunk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers poppunk

popscle

Link to section 'Introduction' of 'popscle' Introduction

Popscle is a suite of population scale analysis tools for single-cell genomics data.

Docker hub: https://hub.docker.com/r/cumulusprod/popscle and its home page on Github.

Link to section 'Versions' of 'popscle' Versions

0.1b

Link to section 'Commands' of 'popscle' Commands

popscle

Link to section 'Module' of 'popscle' Module

You can load the modules by:

module load biocontainers
module load popscle

Link to section 'Example job' of 'popscle' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Popscle on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=popscle
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers popscle

popscle dsc-pileup --sam data/$bam --vcf data/$ref_vcf --out data/$pileup

pplacer

Link to section 'Introduction' of 'pplacer' Introduction

Pplacer places query sequences on a fixed reference phylogenetic tree to maximize phylogenetic likelihood or posterior probability according to a reference alignment, guppy does all of the downstream analysis of placements, and rppr does useful things having to do with reference packages. For more information, please check: BioContainers: https://biocontainers.pro/tools/pplacer
Home page: https://matsen.fhcrc.org/pplacer/

Link to section 'Versions' of 'pplacer' Versions

1.1.alpha19

Link to section 'Commands' of 'pplacer' Commands

pplacer
guppy
rppr

Link to section 'Module' of 'pplacer' Module

You can load the modules by:

module load biocontainers
module load pplacer

Link to section 'Example job' of 'pplacer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pplacer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pplacer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pplacer

prinseq

Link to section 'Introduction' of 'prinseq' Introduction

Prinseq is a tool that generates summary statistics of sequence and quality data and that is used to filter, reformat and trim next-generation sequence data.

For more information, please check its website: https://biocontainers.pro/tools/prinseq and its home page: http://prinseq.sourceforge.net.

Link to section 'Versions' of 'prinseq' Versions

0.20.4

Link to section 'Commands' of 'prinseq' Commands

prinseq-graphs-noPCA.pl
prinseq-graphs.pl
prinseq-lite.pl

Link to section 'Module' of 'prinseq' Module

You can load the modules by:

module load biocontainers
module load prinseq

Link to section 'Example job' of 'prinseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Prinseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=prinseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers prinseq

prinseq-lite.pl -verbose -fastq  SRR5043021_1.fastq -fastq2 SRR5043021_2.fastq -graph_data test.gd -out_good null -out_bad null
prinseq-graphs.pl -i test.gd -png_all -o test
prinseq-graphs-noPCA.pl -i test.gd -png_all -o test_noPCA

prodigal

Link to section 'Introduction' of 'prodigal' Introduction

Prodigal is a tool for fast, reliable protein-coding gene prediction for prokaryotic genome.

For more information, please check its website: https://biocontainers.pro/tools/prodigal and its home page on Github.

Link to section 'Versions' of 'prodigal' Versions

2.6.3

Link to section 'Commands' of 'prodigal' Commands

prodigal

Link to section 'Module' of 'prodigal' Module

You can load the modules by:

module load biocontainers
module load prodigal

Link to section 'Example job' of 'prodigal' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Prodigal on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=prodigal
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers prodigal

prodigal -i genome.fasta -o output.genes -a proteins.faa

prokka

Prokka is a pipeline for rapidly annotating prokaryotic genomes. It produces GFF3, GBK and SQN files that are ready for editing in Sequin and ultimately submitted to Genbank/DDJB/ENA.

Detailed usage can be found here: https://github.com/tseemann/prokka

Link to section 'Versions' of 'prokka' Versions

1.14.6

Link to section 'Module' of 'prokka' Module

You can load the modules by:

module load biocontainers
module load prokka

Link to section 'Example job' of 'prokka' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run prokka on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=prokka
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers prokka

prokka --compliant --centre UoN --outdir PRJEB12345 --locustag EHEC --prefix EHEC-Chr1 contigs.fa  --cpus 24
prokka-genbank_to_fasta_db Coccus1.gbk Coccus2.gbk Coccus3.gbk Coccus4.gbk > Coccus.faa

proteinortho

Link to section 'Introduction' of 'proteinortho' Introduction

Proteinortho is a tool to detect orthologous genes within different species.

For more information, please check its website: https://biocontainers.pro/tools/proteinortho and its home page on Gitlab.

Link to section 'Versions' of 'proteinortho' Versions

6.0.33

Link to section 'Module' of 'proteinortho' Module

You can load the modules by:

module load biocontainers
module load proteinortho

Link to section 'Example job' of 'proteinortho' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Proteinortho on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=proteinortho
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers proteinortho

proteinortho6.pl test/C.faa test/E.faa test/L.faa test/M.faa

prothint

Link to section 'Introduction' of 'prothint' Introduction

ProtHint is a pipeline for predicting and scoring hints (in the form of introns, start and stop codons) in the genome of interest by mapping and spliced aligning predicted genes to a database of reference protein sequences.

Link to section 'Versions' of 'prothint' Versions

2.6.0

Commands
- cds_with_upstream_support.py - combine_gff_records.pl - count_cds_overlaps.py - flag_top_proteins.py - gff_from_region_to_contig.pl - make_chains.py - nucseq_for_selected_genes.pl - print_high_confidence.py - print_longest_isoform.py - proteins_from_gtf.pl - prothint.py - prothint2augustus.py - run_spliced_alignment.pl - run_spliced_alignment_pbs.pl - select_best_proteins.py - select_for_next_iteration.py - spalnBatch.sh - spaln_to_gff.py

Academic license

ProtHint depends on GenMark. To use GeneMark, users need to download license files by yourself.

cd $HOME
wget "replace with license URL"
zcat gm_key_64.gz > .gm_key

Link to section 'Module' of 'prothint' Module

You can load the modules by:

module load biocontainers
module load prothint

Link to section 'Example job' of 'prothint' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ProtHint on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=prothint
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers prothint  
 
prothint.py --threads 4 input/genome.fasta input/proteins.fasta --geneSeeds input/genemark.gtf --workdir test

pullseq

Link to section 'Introduction' of 'pullseq' Introduction

Pullseq is an utility program for extracting sequences from a fasta/fastq file.

BioContainers: https://biocontainers.pro/tools/pullseq
Home page: https://github.com/bcthomas/pullseq

Link to section 'Versions' of 'pullseq' Versions

1.0.2

Link to section 'Commands' of 'pullseq' Commands

pcre-config
pcregrep
pcretest
pullseq
seqdiff

Link to section 'Module' of 'pullseq' Module

You can load the modules by:

module load biocontainers
module load pullseq

Link to section 'Example job' of 'pullseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pullseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pullseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pullseq

purge_dups

Link to section 'Introduction' of 'purge_dups' Introduction

purge_dups is designed to remove haplotigs and contig overlaps in a de novo assembly based on read depth.

BioContainers: https://biocontainers.pro/tools/purge_dups
Home page: https://github.com/dfguan/purge_dups

Link to section 'Versions' of 'purge_dups' Versions

1.2.6

Link to section 'Module' of 'purge_dups' Module

You can load the modules by:

module load biocontainers
module load purge_dups

Link to section 'Example job' of 'purge_dups' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run purge_dups on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=purge_dups
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers purge_dups

pvactools

Link to section 'Introduction' of 'pvactools' Introduction

pVACtools is a cancer immunotherapy tools suite consisting of pVACseq, pVACbind, pVACfuse, pVACvector, and pVACview.

Docker hub: https://hub.docker.com/r/griffithlab/pvactools/
Home page: https://pvactools.readthedocs.io/en/latest/

Link to section 'Versions' of 'pvactools' Versions

3.0.1

Link to section 'Commands' of 'pvactools' Commands

pvacbind
pvacfuse
pvacseq
pvactools
pvacvector
pvacview

Link to section 'Module' of 'pvactools' Module

You can load the modules by:

module load biocontainers
module load pvactools

Link to section 'Example job' of 'pvactools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pvactools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pvactools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pvactools

pvacseq download_example_data .

pvacseq run \
  pvacseq_example_data/input.vcf \
  Test \
  HLA-A*02:01,HLA-B*35:01,DRB1*11:01 \
  MHCflurry MHCnuggetsI MHCnuggetsII NNalign NetMHC PickPocket SMM SMMPMBEC SMMalign \
  pvacseq_output_data \
  -e1 8,9,10 \
  -e2 15 \
  --iedb-install-directory /opt/iedb

pyani

Link to section 'Introduction' of 'pyani' Introduction

Pyani is an application and Python module for whole-genome classification of microbes using Average Nucleotide Identity.

For more information, please check its website: https://biocontainers.pro/tools/pyani and its home page on Github.

Link to section 'Versions' of 'pyani' Versions

0.2.11
0.2.12

Link to section 'Commands' of 'pyani' Commands

average_nucleotide_identity.py
genbank_get_genomes_by_taxon.py
delta_filter_wrapper.py

Link to section 'Module' of 'pyani' Module

You can load the modules by:

module load biocontainers
module load pyani

Link to section 'Example job' of 'pyani' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pyani on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pyani
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pyani

average_nucleotide_identity.py -i tests/ -o tests/test_ANIm_output -m ANIm -g
average_nucleotide_identity.py -i tests/  -o tests/test_ANIb_output -m ANIb -g
average_nucleotide_identity.py -i tests/ -o tests/test_ANIblastall_output -m ANIblastall -g
average_nucleotide_identity.py -i tests/  -o tests/test_TETRA_output -m TETRA -g

pybedtools

Link to section 'Introduction' of 'pybedtools' Introduction

Pybedtools wraps and extends BEDTools and offers feature-level manipulations from within Python.

For more information, please check its website: https://biocontainers.pro/tools/pybedtools and its home page on Github.

Link to section 'Versions' of 'pybedtools' Versions

0.9.0

Link to section 'Commands' of 'pybedtools' Commands

python
python3

Link to section 'Module' of 'pybedtools' Module

You can load the modules by:

module load biocontainers
module load pybedtools

Link to section 'Example job' of 'pybedtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pybedtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pybedtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pybedtools

pybigwig

Link to section 'Introduction' of 'pybigwig' Introduction

Pybigwig is a python extension, written in C, for quick access to bigBed files and access to and creation of bigWig files.

For more information, please check its website: https://biocontainers.pro/tools/pybigwig and its home page on Github.

Link to section 'Versions' of 'pybigwig' Versions

0.3.18

Link to section 'Commands' of 'pybigwig' Commands

python
python3

Link to section 'Module' of 'pybigwig' Module

You can load the modules by:

module load biocontainers
module load pybigwig

Link to section 'Interactive job' of 'pybigwig' Interactive job

To run pybigwig interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers pybigwig
(base) UserID@bell-a008:~ $ python
Python 3.6.15 |  packaged by conda-forge |  (default, Dec  3 2021, 18:49:41)  
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import pyBigWig
>>> bw = pyBigWig.open("test/test.bw")

Link to section 'Batch job' of 'pybigwig' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run batch jobs on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pybigwig
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pybigwig

python script.py

pychopper

Link to section 'Introduction' of 'pychopper' Introduction

Pychopper is a tool to identify, orient and trim full-length Nanopore cDNA reads. The tool is also able to rescue fused reads.

BioContainers: https://biocontainers.pro/tools/pychopper
Home page: https://github.com/nanoporetech/pychopper

Link to section 'Versions' of 'pychopper' Versions

2.5.0

Link to section 'Commands' of 'pychopper' Commands

cdna_classifier.py

Link to section 'Module' of 'pychopper' Module

You can load the modules by:

module load biocontainers
module load pychopper

Link to section 'Example job' of 'pychopper' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pychopper on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pychopper
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pychopper

pycoqc

Link to section 'Introduction' of 'pycoqc' Introduction

Pycoqc is a tool that computes metrics and generates interactive QC plots for Oxford Nanopore technologies sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/pycoqc and its home page on Github.

Link to section 'Versions' of 'pycoqc' Versions

2.5.2

Link to section 'Commands' of 'pycoqc' Commands

pycoQC
python
python3

Link to section 'Module' of 'pycoqc' Module

You can load the modules by:

module load biocontainers
module load pycoqc

Link to section 'Example job' of 'pycoqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pycoqc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pycoqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pycoqc

pycoQC \
    -f Albacore-1.2.1_basecall-1D-DNA_sequencing_summary.txt\
     -o Albacore-1.2.1_basecall-1D-DNA.html \
    --quiet

pyensembl

Link to section 'Introduction' of 'pyensembl' Introduction

Pyensembl is a Python interface to Ensembl reference genome metadata such as exons and transcripts.

For more information, please check its website: https://biocontainers.pro/tools/pyensembl and its home page on Github.

Link to section 'Versions' of 'pyensembl' Versions

1.9.4

Link to section 'Commands' of 'pyensembl' Commands

pyensembl
python
python3

Link to section 'Module' of 'pyensembl' Module

You can load the modules by:

module load biocontainers
module load pyensembl

Link to section 'Example job' of 'pyensembl' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pyensembl on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pyensembl
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pyensembl

pyfaidx

Link to section 'Introduction' of 'pyfaidx' Introduction

Pyfaidx is a Python package for random access and indexing of fasta files.

For more information, please check its website: https://biocontainers.pro/tools/pyfaidx and its home page on Github.

Link to section 'Versions' of 'pyfaidx' Versions

0.6.4

Link to section 'Commands' of 'pyfaidx' Commands

python
python3

Link to section 'Module' of 'pyfaidx' Module

You can load the modules by:

module load biocontainers
module load pyfaidx

Link to section 'Example job' of 'pyfaidx' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pyfaidx on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pyfaidx
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pyfaidx

pygenometracks

Link to section 'Introduction' of 'pygenometracks' Introduction

pyGenomeTracks aims to produce high-quality genome browser tracks that are highly customizable.

BioContainers: https://biocontainers.pro/tools/pygenometracks
Home page: https://github.com/deeptools/pyGenomeTracks

Link to section 'Versions' of 'pygenometracks' Versions

Link to section 'Commands' of 'pygenometracks' Commands

make_tracks_file
pyGenomeTracks

Link to section 'Module' of 'pygenometracks' Module

You can load the modules by:

module load biocontainers
module load pygenometracks

Link to section 'Example job' of 'pygenometracks' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pygenometracks on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pygenometracks
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pygenometracks

make_tracks_file --trackFiles domains.bed bigwig.bw -o tracks.ini

pyGenomeTracks --tracks tracks.ini \
   --region chr2:10,000,000-11,000,000 --outFileName nice_image.pdf

pygenomeviz

Link to section 'Introduction' of 'pygenomeviz' Introduction

pyGenomeViz is a genome visualization python package for comparative genomics implemented based on matplotlib.

Docker hub: https://hub.docker.com/r/staphb/pygenomeviz
Home page: https://github.com/moshi4/pyGenomeViz#cli-examples

Link to section 'Versions' of 'pygenomeviz' Versions

0.2.2

Link to section 'Commands' of 'pygenomeviz' Commands

pgv-download-dataset
pgv-mmseqs
pgv-mummer
pgv-pmauve
python
python3

Link to section 'Module' of 'pygenomeviz' Module

You can load the modules by:

module load biocontainers
module load pygenomeviz

Link to section 'Example job' of 'pygenomeviz' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pygenomeviz on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pygenomeviz
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pygenomeviz

pyranges

Link to section 'Introduction' of 'pyranges' Introduction

Pyranges are collections of intervals that support comparison operations (like overlap and intersect) and other methods that are useful for genomic analyses.

For more information, please check its website: https://biocontainers.pro/tools/pyranges and its home page on Github.

Link to section 'Versions' of 'pyranges' Versions

0.0.115

Link to section 'Commands' of 'pyranges' Commands

python
python3

Link to section 'Module' of 'pyranges' Module

You can load the modules by:

module load biocontainers
module load pyranges

Link to section 'Example job' of 'pyranges' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pyranges on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pyranges
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pyranges

pysam

Link to section 'Introduction' of 'pysam' Introduction

Pysam is a python module that makes it easy to read and manipulate mapped short read sequence data stored in SAM/BAM files.

For more information, please check its website: https://biocontainers.pro/tools/pysam and its home page on Github.

Link to section 'Versions' of 'pysam' Versions

0.18.0

Link to section 'Commands' of 'pysam' Commands

python
python3

Link to section 'Module' of 'pysam' Module

You can load the modules by:

module load biocontainers
module load pysam

Link to section 'Example job' of 'pysam' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Pysam on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pysam
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pysam

pyvcf3

Link to section 'Introduction' of 'pyvcf3' Introduction

PyVCF3 has been created because the Official PyVCF repository is no longer maintained and do not accept any pull requests.

BioContainers: https://biocontainers.pro/tools/pyvcf3
Home page: https://github.com/dridk/PyVCF3

Link to section 'Versions' of 'pyvcf3' Versions

1.0.3

Link to section 'Commands' of 'pyvcf3' Commands

python
python3

Link to section 'Module' of 'pyvcf3' Module

You can load the modules by:

module load biocontainers
module load pyvcf3

Link to section 'Example job' of 'pyvcf3' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run pyvcf3 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=pyvcf3
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers pyvcf3

qiime2

Link to section 'Introduction' of 'qiime2' Introduction

QIIME 2 is a is a powerful, extensible, and decentralized microbiome analysis package with a focus on data and analysis transparency. QIIME 2 enables researchers to start an analysis with raw DNA sequence data and finish with publication-quality figures and statistical results.

For more information, please check its website: https://quay.io/repository/qiime2/core and its home page: https://qiime2.org/.

Link to section 'Versions' of 'qiime2' Versions

2021.2
2022.11
2022.2
2022.8
2023.2
2023.5
2023.7

Link to section 'Commands' of 'qiime2' Commands

biom
qiime
python
python3

Link to section 'Module' of 'qiime2' Module

You can load the modules by:

module load biocontainers
module load qiime2

Link to section 'Example job' of 'qiime2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run QIIME 2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=qiime2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers qiime2

qiime metadata tabulate \
    --m-input-file rep-seqs.qza \
    --m-input-file taxonomy.qza \
    --o-visualization tabulated-feature-metadata.qzv

qtlseq

Link to section 'Introduction' of 'qtlseq' Introduction

Bulked segregant analysis, as implemented in QTL-seq (Takagi et al., 2013), is a powerful and efficient method to identify agronomically important loci in crop plants. QTL-seq was adapted from MutMap to identify quantitative trait loci. It utilizes sequences pooled from two segregating progeny populations with extreme opposite traits (e.g. resistant vs susceptible) and a single whole-genome resequencing of either of the parental cultivars.

BioContainers: https://biocontainers.pro/tools/qtlseq
Home page: https://github.com/YuSugihara/QTL-seq#What-is-QTL-seq

Link to section 'Versions' of 'qtlseq' Versions

2.2.3

Link to section 'Commands' of 'qtlseq' Commands

qtlseq

Link to section 'Module' of 'qtlseq' Module

You can load the modules by:

module load biocontainers
module load qtlseq

Link to section 'Example job' of 'qtlseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run qtlseq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=qtlseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers qtlseq

qualimap

Link to section 'Introduction' of 'qualimap' Introduction

Qualimap is a platform-independent application written in Java and R that provides both a Graphical User Interface (GUI) and a command-line interface to facilitate the quality control of alignment sequencing data and its derivatives like feature counts.

For more information, please check its website: https://biocontainers.pro/tools/qualimap and its home page: http://qualimap.conesalab.org.

Link to section 'Versions' of 'qualimap' Versions

2.2.1

Link to section 'Commands' of 'qualimap' Commands

qualimap

Link to section 'Module' of 'qualimap' Module

You can load the modules by:

module load biocontainers
module load qualimap

Link to section 'Example job' of 'qualimap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Qualimap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=qualimap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers qualimap

quast

Link to section 'Introduction' of 'quast' Introduction

Quast is Quality Assessment Tool for Genome Assemblies.

Note: Running QUAST, please use the command: quast.py metaquast.py'

For more information, please check its website: https://biocontainers.pro/tools/quast and its home page on Github.

Link to section 'Versions' of 'quast' Versions

5.0.2
5.2.0

Link to section 'Commands' of 'quast' Commands

quast.py
metaquast.py

Link to section 'Module' of 'quast' Module

You can load the modules by:

module load biocontainers
module load quast

Link to section 'Example job' of 'quast' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Quast on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=quast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers quast

metaquast.py  --gene-finding --threads 8  \ 
    meta_contigs_1.fasta meta_contigs_2.fasta \
    -r meta_ref_1.fasta,meta_ref_2.fasta,meta_ref_3.fasta \
    -o quast_out_genefinding

quickmirseq

Link to section 'Introduction' of 'quickmirseq' Introduction

QuickMIRSeq is an integrated pipeline for quick and accurate quantification of known miRNAs and isomiRs by jointly processing multiple samples.

Docker hub: https://hub.docker.com/r/gcfntnu/quickmirseq and its home page on Github.

Link to section 'Versions' of 'quickmirseq' Versions

Link to section 'Commands' of 'quickmirseq' Commands

perl
QuickMIRSeq-report.sh

Link to section 'Module' of 'quickmirseq' Module

You can load the modules by:

module load biocontainers
module load quickmirseq

This module defines program installation directory (note: inside the container!) as environment variable $QuickMIRSeq. Once again, this is not a host path, this path is only available from inside the container.

With the way this module is organized, you should be able to use the variable freely for both the perl $QuickMIRSeq/QuickMIRSeq.pl allIDs.txt run.config and the $QuickMIRSeq/QuickMIRSeq-report.sh steps as directed by the user guide.

A simple QuickMIRSeq.pl and QuickMIRSeq-report.sh will also work (and can be a backup if the variable expansion somehow does not work for you).

You will also need a run configuration file. You can copy from an existing one, or take from the user guide, or as a last resort, use Singularity to copy the template (in $QuickMIRSeq/run.config.template) from inside the container image. singularity shell may be an easiest way for the latter.

Link to section 'Example job' of 'quickmirseq' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run QuickMIRSeq on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=quickmirseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers quickmirseq

quickmerge -d out.rq.delta -q q.fasta -r scab8722.fasta  -hco 5.0 -c 1.5 -l n -ml m -p prefix

r

Link to section 'Introduction' of 'r' Introduction

R is a system for statistical computation and graphics.

This is a plain R-base installation (see https://github.com/rocker-org/rocker/) repackaged by RCAC with an addition of a handful prerequisite libraries (libcurl, libopenssl, libxml2, libcairo2 and libXt) and their header files.

Docker hub: https://hub.docker.com/_/r-base and its home page: https://www.r-project.org/.

Link to section 'Versions' of 'r' Versions

4.1.1

Link to section 'Commands' of 'r' Commands

R
Rscript

Link to section 'Module' of 'r' Module

You can load the modules by:

module load biocontainers
module load r

Link to section 'Example job' of 'r' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run R on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=r
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers r

r-rnaseq

r-rnaseq is a customerized R module based on R/4.1.1 used for RNAseq analysis.

In the module, we have some packages installed:

BiocManager 1.30.16
ComplexHeatmap 2.9.4
DESeq2 1.34.0
edgeR 3.36.0
pheatmap 1.0.12
limma 3.48.3
tibble 3.1.5
tidyr 1.1.4
readr 2.0.2
readxl 1.3.1
purrr 0.3.4
dplyr 1.0.7
stringr 1.4.0
forcats 0.5.1
ggplot2 3.3.5
openxlsx 4.2.5

Link to section 'Versions' of 'r-rnaseq' Versions

4.1.1-1
4.1.1-1-rstudio

Link to section 'Commands' of 'r-rnaseq' Commands

R
Rscript
rstudio (only for the rstudio version)

Link to section 'Module' of 'r-rnaseq' Module

You can load the modules by:

module load biocontainers  
module load r-rnaseq/4.1.1-1
# If you want to use Rstudio, load the rstudio version
module load r-rnaseq/4.1.1-1-rstudio

Install packages

Users can also install packages they need. The installed location depends on the setting in your ~/.Rprofile.
Detailed guide about installing R packages can be found here: https://www.rcac.purdue.edu/knowledge/bell/run/examples/apps/r/package.

Link to section 'Interactive job' of 'r-rnaseq' Interactive job

To run interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers r-rnaseq/4.1.1-1 # or r-rnaseq/4.1.1-1-rstudio 
(base) UserID@bell-a008:~ $ R

R version 4.1.1 (2021-08-10) -- "Kick Things"
Copyright (C) 2021 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.


> library(edgeR)
> library(pheatmap)

Link to section 'Batch job' of 'r-rnaseq' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=r_RNAseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers r-rnaseq

Rscript RNAseq.R

r-rstudio

Link to section 'Introduction' of 'r-rstudio' Introduction

RStudio is an integrated development environment (IDE) for the R statistical computation and graphics system.

This is an RStudio IDE together with a plain R-base installation (see https://github.com/rocker-org/rocker/), repackaged by RCAC with an addition of a handful prerequisite libraries (libcurl, libopenssl, libxml2, libcairo2 and libXt) and their header files. It is intentionally separate from the biocontainers' 'r' module for reasons of image size (700MB vs 360MB).

Docker hub: https://hub.docker.com/_/r-base and its home page: https://www.rstudio.com/products/rstudio/ and https://www.r-project.org/.

Link to section 'Versions' of 'r-rstudio' Versions

4.1.1

Link to section 'Commands' of 'r-rstudio' Commands

R
Rscript
rstudio

Link to section 'Module' of 'r-rstudio' Module

You can load the modules by:

module load biocontainers
module load r-studio

Link to section 'Example job' of 'r-rstudio' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RStudio on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=r-studio
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers r-studio

r-scrnaseq

r-scrnaseq is a customerized R module based on R/4.1.1 or R/4.2.0 used for scRNAseq analysis.

In the module, we have some packages installed:

BiocManager 1.30.16
CellChat 1.6.1
ProjecTILs 3.0
Seurat 4.1.0
SeuratObject 4.0.4
SeuratWrappers 0.3.0
monocle3 1.0.0
SnapATAC 1.0.0
SingleCellExperiment 1.14.1, 1.16.0
scDblFinder 1.8.0
SingleR 1.8.1
scCATCH 3.0
scMappR 1.0.7
rliger 1.0.0
schex 1.8.0
CoGAPS 3.14.0
celldex 1.4.0
dittoSeq 1.6.0
DropletUtils 1.14.2
miQC 1.2.0
Nebulosa 1.4.0
tricycle 1.2.0
pheatmap 1.0.12
limma 3.48.3, 3.50.0
tibble 3.1.5
tidyr 1.1.4
readr 2.0.2
readxl 1.3.1
purrr 0.3.4
dplyr 1.0.7
stringr 1.4.0
forcats 0.5.1
ggplot2 3.3.5
openxlsx 4.2.5

Link to section 'Versions' of 'r-scrnaseq' Versions

4.1.1-1
4.1.1-1-rstudio
4.2.0
4.2.0-rstudio
r-scrnaseq/4.2.3-rstudio

Link to section 'Commands' of 'r-scrnaseq' Commands

R
Rscript
rstudio (only for the rstudio version)

Link to section 'Module' of 'r-scrnaseq' Module

You can load the modules by:

module load biocontainers  
module load r-scrnaseq
# or module load r-scrnaseq/4.2.0
# If you want to use Rstudio, load the rstudio version
module load r-scrnaseq/4.1.1-1-rstudio 
# or module load r-scrnaseq/4.2.0-rstudio

Install packages

Link to section 'Interactive job' of 'r-scrnaseq' Interactive job

To run interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers r-scrnaseq/4.2.0 # or r-scrnaseq/4.2.0-rstudio 
(base) UserID@bell-a008:~ $ R

R version 4.2.0 (2022-04-22) -- "Vigorous Calisthenics"
Copyright (C) 2022 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.


> library(Seurat)
> library(monocle3)

Link to section 'Batch job' of 'r-scrnaseq' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=r_scRNAseq
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers r-scrnaseq

Rscript scRNAseq.R

racon

Link to section 'Introduction' of 'racon' Introduction

Racon is a consensus module for raw de novo DNA assembly of long uncorrected reads.

For more information, please check its website: https://biocontainers.pro/tools/racon and its home page on Github.

Link to section 'Versions' of 'racon' Versions

1.4.20
1.5.0

Link to section 'Commands' of 'racon' Commands

racon

Link to section 'Module' of 'racon' Module

You can load the modules by:

module load biocontainers
module load racon

Link to section 'Example job' of 'racon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Racon on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=racon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers racon

ragout

Link to section 'Introduction' of 'ragout' Introduction

Ragout is a tool for chromosome-level scaffolding using multiple references.

For more information, please check its website: https://biocontainers.pro/tools/ragout and its home page on Github.

Link to section 'Versions' of 'ragout' Versions

Link to section 'Commands' of 'ragout' Commands

ragout

Link to section 'Module' of 'ragout' Module

You can load the modules by:

module load biocontainers
module load ragout

Link to section 'Example job' of 'ragout' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ragout on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ragout
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ragout

ragtag

Link to section 'Introduction' of 'ragtag' Introduction

Ragtag is a tool for fast reference-guided genome assembly scaffolding.

For more information, please check its website: https://biocontainers.pro/tools/ragtag and its home page on Github.

Link to section 'Versions' of 'ragtag' Versions

2.1.0

Link to section 'Commands' of 'ragtag' Commands

ragtag.py

Link to section 'Module' of 'ragtag' Module

You can load the modules by:

module load biocontainers
module load ragtag

Link to section 'Example job' of 'ragtag' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Ragtag on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ragtag
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ragtag

ragtag.py correct ref.fasta query.fasta
ragtag.py patch target.fa query.fa

rapmap

Link to section 'Introduction' of 'rapmap' Introduction

RapMap is a testing ground for ideas in quasi-mapping and selective alignment.

BioContainers: https://biocontainers.pro/tools/rapmap
Home page: https://github.com/COMBINE-lab/RapMap

Link to section 'Versions' of 'rapmap' Versions

0.6.0

Link to section 'Commands' of 'rapmap' Commands

rapmap

Link to section 'Module' of 'rapmap' Module

You can load the modules by:

module load biocontainers
module load rapmap

Link to section 'Example job' of 'rapmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run rapmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rapmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rapmap

rasusa

Link to section 'Introduction' of 'rasusa' Introduction

Rasusa: Randomly subsample sequencing reads to a specified coverage.

Docker hub: https://hub.docker.com/r/staphb/rasusa
Home page: https://github.com/mbhall88/rasusa

Link to section 'Versions' of 'rasusa' Versions

0.6.0
0.7.0

Link to section 'Commands' of 'rasusa' Commands

rasusa

Link to section 'Module' of 'rasusa' Module

You can load the modules by:

module load biocontainers
module load rasusa

Link to section 'Example job' of 'rasusa' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run rasusa on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rasusa
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rasusa

rasusa -i seq_1.fq -i seq_2.fq  \
    --coverage 100 --genome-size 35mb  \
    -o out.r1.fq -o out.r2.fq

raven-assembler

Link to section 'Introduction' of 'raven-assembler' Introduction

Raven-assembler is a de novo genome assembler for long uncorrected reads.

For more information, please check its website: https://biocontainers.pro/tools/raven-assembler and its home page on Github.

Link to section 'Versions' of 'raven-assembler' Versions

1.8.1

Link to section 'Commands' of 'raven-assembler' Commands

raven

Link to section 'Module' of 'raven-assembler' Module

You can load the modules by:

module load biocontainers
module load raven-assembler

Link to section 'Example job' of 'raven-assembler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Raven-assembler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=raven-assembler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers raven-assembler

raven -t 12 input.fastq

raxml

Link to section 'Introduction' of 'raxml' Introduction

Raxml (Randomized Axelerated Maximum Likelihood) is a program for the Maximum Likelihood-based inference of large phylogenetic trees.

For more information, please check its website: https://biocontainers.pro/tools/raxml and its home page: https://cme.h-its.org/exelixis/web/software/raxml/.

Link to section 'Versions' of 'raxml' Versions

8.2.12

Link to section 'Commands' of 'raxml' Commands

raxmlHPC
raxmlHPC-AVX2
raxmlHPC-PTHREADS
raxmlHPC-PTHREADS-AVX2
raxmlHPC-PTHREADS-SSE3
raxmlHPC-SSE3

Link to section 'Module' of 'raxml' Module

You can load the modules by:

module load biocontainers
module load raxml

Link to section 'Example job' of 'raxml' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Raxml on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 36
#SBATCH --job-name=raxml
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers raxml

raxmlHPC-SSE3 -m GTRGAMMA  -p 12345 -s input.fasta -n HPC-SSE3_out -# 20 -T 36
raxmlHPC -m GTRGAMMA  -p 12345 -s input.fasta -n HPC_out -# 20 -T 36
raxmlHPC-AVX2  -m GTRGAMMA  -p 12345 -s input.fasta -n HPC-AVX2_out -# 20 -T 36 
raxmlHPC-PTHREADS  -m GTRGAMMA  -p 12345 -s input.fasta -n HPC-PTHREADS_out -# 20 -T 36
raxmlHPC-PTHREADS-AVX2  -m GTRGAMMA  -p 12345 -s input.fasta -n HPC-PTHREADS-AVX2_out -# 20 -T 36
raxmlHPC-PTHREADS-SSE3  -m GTRGAMMA  -p 12345 -s input.fasta -n HPC-PTHREADS-SSE3_out -# 20 -T 36

raxml-ng

Link to section 'Introduction' of 'raxml-ng' Introduction

Raxml-ng is a phylogenetic tree inference tool which uses maximum-likelihood (ML) optimality criterion.

For more information, please check its website: https://biocontainers.pro/tools/raxml-ng and its home page on Github.

Link to section 'Versions' of 'raxml-ng' Versions

1.1.0

Link to section 'Commands' of 'raxml-ng' Commands

raxml-ng
raxml-ng-mpi
mpirun
mpiexec

Link to section 'Module' of 'raxml-ng' Module

You can load the modules by:

module load biocontainers
module load raxml-ng

Link to section 'Example job' of 'raxml-ng' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Raxml-ng on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=raxml-ng
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers raxml-ng

raxml-ng --bootstrap --msa alignment.phy \
     --model GTR+G --threads 12 --bs-trees 1000

reapr

Link to section 'Introduction' of 'reapr' Introduction

Reapr is a tool that evaluates the accuracy of a genome assembly using mapped paired end reads.

BioContainers: https://biocontainers.pro/tools/reapr
Home page: https://www.sanger.ac.uk/tool/reapr/

Link to section 'Notes provided by Neelam Jha' of 'reapr' Notes provided by Neelam Jha

https://bioinformaticsonline.com/bookmarks/view/26925/reapr-a-universal-tool-for-genome-assembly-evaluation

Reapr is a tool trying to find explicit errors in the assembly based on incongruently mapped reads. It is heavily based on too low span coverage, or reads mapping too far or too close to each other. The program will also break up contigs/scaffolds at spurious sites to form smaller (but hopefully correct) contigs. Reapr runs pretty slowly, sadly,

Reapr is a bit fuzzy with contig names, but luckily it’s given us a tool to check if things are ok before we proceed! The command reapr facheck <assembly.fasta> will tell you if everything’s ok! in this case, no output is good output, since the only output from the command is the potential problems with the contig names. If you run into any problems, run reapr facheck <assembly.fasta> <renamed_assembly.fasta>, and you will get an assembly file with renamed contigs.

Once the names are ok, we continue:

The first thing we reapr needs, is a list of all “perfect” reads. This is reads that have a perfect map to the reference. Reapr is finicky though, and can’t use libraries with different read lengths, so you’ll have to use assemblies based on the raw data for this. Run the command reapr perfectmap to get information on how to create a perfect mapping file, and create a perfect mapping called <assembler>_perfect.

The next tool we need is reapr smaltmap which creates a bam file of read-pair mappings. Do the same thing you did with perfectmap and create an output file called <assembler>_smalt.bam.

Finally we can use the smalt mapping, and the perfect mapping to run the reapr pipeline. Run reapr pipeline to get help on how to run, and then run the pipeline. Store the results in reapr_<assembler>.

Link to section 'Versions' of 'reapr' Versions

1.0.18

Link to section 'Commands' of 'reapr' Commands

reapr

Link to section 'Module' of 'reapr' Module

You can load the modules by:

module load biocontainers
module load reapr

Link to section 'Example job' of 'reapr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run reapr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=reapr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers reapr

reapr facheck Assembly.fasta renamedAssembly.fasta
reapr perfectmap renamedAssembly.fasta reads_1.fastq reads_2.fastq 100 outputPrefix
reapr smaltmap renamedAssembly.fasta reads_1.fastq reads_2.fastq mapped.bam
reapr pipeline renamedAssembly.fasta mapped.bam pipeoutdir outputPrefix

rebaler

Link to section 'Introduction' of 'rebaler' Introduction

Rebaler is a program for conducting reference-based assemblies using long reads.

For more information, please check its website: https://biocontainers.pro/tools/rebaler and its home page on Github.

Link to section 'Versions' of 'rebaler' Versions

0.2.0

Link to section 'Commands' of 'rebaler' Commands

rebaler

Link to section 'Module' of 'rebaler' Module

You can load the modules by:

module load biocontainers
module load rebaler

Link to section 'Example job' of 'rebaler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Rebaler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rebaler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rebaler

reciprocal_smallest_distance

Link to section 'Introduction' of 'reciprocal_smallest_distance' Introduction

The reciprocal smallest distance (RSD) algorithm accurately infers orthologs between pairs of genomes by considering global sequence alignment and maximum likelihood evolutionary distance between sequences.

For more information, please check its home page on Github.

Link to section 'Versions' of 'reciprocal_smallest_distance' Versions

1.1.7

Link to section 'Commands' of 'reciprocal_smallest_distance' Commands

rsd_search
rsd_blast
rsd_format

Link to section 'Module' of 'reciprocal_smallest_distance' Module

You can load the modules by:

module load biocontainers
module load reciprocal_smallest_distance

Link to section 'Example job' of 'reciprocal_smallest_distance' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Reciprocal Smallest Distance on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=reciprocal_smallest_distance
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers reciprocal_smallest_distance

rsd_search 
    -q Mycoplasma_genitalium.aa \
    --subject-genome=Mycobacterium_leprae.aa \
    -o Mycoplasma_genitalium.aa_Mycobacterium_leprae.aa_0.8_1e-5.orthologs.txt

rsd_format -g Mycoplasma_genitalium.aa

rsd_blast -v -q Mycoplasma_genitalium.aa \
    --subject-genome=Mycobacterium_leprae.aa \
    --forward-hits q_s.hits --reverse-hits s_q.hits \
    --no-format --evalue 0.1

recycler

Link to section 'Introduction' of 'recycler' Introduction

Recycler is a tool designed for extracting circular sequences from de novo assembly graphs.

For more information, please check its website: https://biocontainers.pro/tools/recycler and its home page on Github.

Link to section 'Versions' of 'recycler' Versions

Link to section 'Commands' of 'recycler' Commands

make_fasta_from_fastg.py
get_simple_cycs.py
recycle.py

Link to section 'Module' of 'recycler' Module

You can load the modules by:

module load biocontainers
module load recycler

Link to section 'Example job' of 'recycler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Recycler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=recycler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers recycler

recycle.py -g test/assembly_graph.fastg \ 
    -k 55 -b test/test.sort.bam -i True

regtools

Link to section 'Introduction' of 'regtools' Introduction

Regtools are tools that integrate DNA-seq and RNA-seq data to help interpret mutations in a regulatory and splicing context.

Docker hub: https://hub.docker.com/r/griffithlab/regtools/
Home page: https://github.com/griffithlab/regtools

Link to section 'Versions' of 'regtools' Versions

1.0.0

Link to section 'Commands' of 'regtools' Commands

regtools

Link to section 'Module' of 'regtools' Module

You can load the modules by:

module load biocontainers
module load regtools

Link to section 'Example job' of 'regtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run regtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=regtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers regtools

repeatmasker

Link to section 'Introduction' of 'repeatmasker' Introduction

RepeatMakser is a program that screens DNA sequences for interspersed repeats and low complexity DNA sequences.
Detailed usage can be found here: http://www.repeatmasker.org.

Link to section 'Versions' of 'repeatmasker' Versions

4.1.2

Commands
- RepeatMasker

Database

As of May 20, 2019 GIRI has rescinded the working agreement allowing the www.repeatmasker.org website to offer a repeatmasking service utilizing the RepBase RepeatMasker Edition library. As a result, repeatmasker can only offer masking using the open database Dfam, which starting in 3.0 includes consensus sequences in addition to profile hidden Markov models for many transposable element families. Users requiring RepBase will need to purchase a commercial or academic license from GIRI and run RepeatMasker localy.

In our cluster, we set up the Dfam release 3.5 (October 2021) that include 285,580 repetitive DNA families.

Species name

Since v4.1.1, RepeatMakser has switched to the FamDB format for the Dfam database. Due to this change, RepeatMasker becomes more strict with regards to what is acceptable for the -species flag. The commonly used names such as "mammal" and "mouse" will not be accepted. To check for valid names, you can query the database using the python script famdb.py (https://github.com/Dfam-consortium/FamDB).

See famdb.py --help for usage information and below for an example the check the valid name for "mammal" using our copy of the Dfam database:

/depot/itap/datasets/Maker/RepeatMasker/Libraries/famdb.py -i /depot/itap/datasets/Maker/RepeatMasker/Libraries/Dfam.h5 names mammal

Link to section 'Module' of 'repeatmasker' Module

You can load the modules by:

module load biocontainers
module load repeatmasker/4.1.2

Link to section 'Example job' of 'repeatmasker' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RepeatMasker on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 2:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=repeatmsker
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers repeatmasker/4.1.2 

RepeatMasker -pa 24 -species mammals genome.fasta

repeatmodeler

Link to section 'Introduction' of 'repeatmodeler' Introduction

RepeatModeler is a de novo transposable element (TE) family identification and modeling package.

For more information, please check its website: https://biocontainers.pro/tools/repeatmodeler and its home page: http://www.repeatmasker.org/RepeatModeler/.

Link to section 'Versions' of 'repeatmodeler' Versions

2.0.2
2.0.3

Link to section 'Commands' of 'repeatmodeler' Commands

RepeatModeler
BuildDatabase
RepeatClassifier

Link to section 'Module' of 'repeatmodeler' Module

You can load the modules by:

module load biocontainers
module load repeatmodeler

Link to section 'Example job' of 'repeatmodeler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RepeatModeler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=repeatmodeler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers repeatmodeler

repeatscout

Link to section 'Introduction' of 'repeatscout' Introduction

RepeatScout is a tool to discover repetitive substrings in DNA.

For more information, please check its website: https://biocontainers.pro/tools/repeatscout and its home page on Github.

Link to section 'Versions' of 'repeatscout' Versions

1.0.6

Link to section 'Commands' of 'repeatscout' Commands

RepeatScout
build_lmer_table
compare-out-to-gff.prl
filter-stage-1.prl
filter-stage-2.prl
merge-lmer-tables.prl

Link to section 'Module' of 'repeatscout' Module

You can load the modules by:

module load biocontainers
module load repeatscout

Link to section 'Example job' of 'repeatscout' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RepeatScout on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=repeatscout
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers repeatscout

build_lmer_table -l 14 -sequence genome.fasta -freq Final_assembly.freq

RepeatScout -sequence genome.fasta -output Final_assembly_repeats.fasta -freq Final_assembly.freq -l 14

resfinder

Link to section 'Introduction' of 'resfinder' Introduction

ResFinder identifies acquired antimicrobial resistance genes in total or partial sequenced isolates of bacteria.

Home page: https://github.com/cadms/resfinder

Link to section 'Versions' of 'resfinder' Versions

4.1.5

Link to section 'Commands' of 'resfinder' Commands

run_resfinder.py
run_batch_resfinder.py

Link to section 'Module' of 'resfinder' Module

You can load the modules by:

module load biocontainers
module load resfinder

Link to section 'Example job' of 'resfinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run resfinder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=resfinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers resfinder

run_resfinder.py -o output -db_res db_resfinder/ \
     -db_res_kma db_resfinder/kma_indexing -db_point db_pointfinder/ \
     -s "Escherichia coli" --acquired --point -ifq data/test_isolate_01_*

revbayes

Link to section 'Introduction' of 'revbayes' Introduction

RevBayes -- Bayesian phylogenetic inference using probabilistic graphical models and an interactive language.

Home page: https://github.com/revbayes/revbayes

Link to section 'Versions' of 'revbayes' Versions

1.1.1

Link to section 'Commands' of 'revbayes' Commands

rb
rb-mpi

Link to section 'Module' of 'revbayes' Module

You can load the modules by:

module load biocontainers
module load revbayes

Link to section 'Example job' of 'revbayes' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run revbayes on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=revbayes
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers revbayes

rmats

MATS is a computational tool to detect differential alternative splicing events from RNA-Seq data. The statistical model of MATS calculates the P-value and false discovery rate that the difference in the isoform ratio of a gene between two conditions exceeds a given user-defined threshold. From the RNA-Seq data, MATS can automatically detect and analyze alternative splicing events corresponding to all major types of alternative splicing patterns. MATS handles replicate RNA-Seq data from both paired and unpaired study design.

Detailed usage can be found here: http://rnaseq-mats.sourceforge.net

Link to section 'Versions' of 'rmats' Versions

4.1.1

Link to section 'Commands' of 'rmats' Commands

rmats.py

Link to section 'Module' of 'rmats' Module

You can load the modules by:

module load biocontainers
module load rmats

Link to section 'Example job' of 'rmats' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run rmats on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=rmats
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rmats

rmats.py --b1 SR_b1.txt --b2 SR_b2.txt --gtf Homo_sapiens.GRCh38.105.gtf --od rmats_out_homo --tmp rmats_tmp  -t paired --nthread 10 --readLength 150

rmats2sashimiplot

rmats2sashimiplot produces a sashimiplot visualization of rMATS output. rmats2sashimiplot can also produce plots using an annotation file and genomic coordinates. The plotting backend is MISO.

Detailed usage can be found here: https://github.com/Xinglab/rmats2sashimiplot

Link to section 'Versions' of 'rmats2sashimiplot' Versions

2.0.4

Link to section 'Commands' of 'rmats2sashimiplot' Commands

rmats2sashimiplot

Link to section 'Module' of 'rmats2sashimiplot' Module

You can load the modules by:

module load biocontainers
module load rmats2sashimiplot

Link to section 'Example job' of 'rmats2sashimiplot' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run rmats on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=rmats2sashimiplot
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rmats2sashimiplot

rmats2sashimiplot --s1 sample_1_replicate_1.sam,sample_1_replicate_2.sam,sample_1_replicate_3.sam \
                  --s2 sample_2_replicate_1.sam,sample_2_replicate_2.sam,sample_2_replicate_3.sam \
                  -t SE -e SE.MATS.JC.txt --l1 SampleOne --l2 SampleTwo --exon_s 1 --intron_s 5 \
                  -o test_events_output

rnaindel

Link to section 'Introduction' of 'rnaindel' Introduction

RNAIndel calls coding indels from tumor RNA-Seq data and classifies them as somatic, germline, and artifactual. RNAIndel supports GRCh38 and 37.

For more information, please check its Github package: https://github.com/stjude/RNAIndel/pkgs/container/rnaindel and its home page on Github.

Link to section 'Versions' of 'rnaindel' Versions

3.0.9

Link to section 'Commands' of 'rnaindel' Commands

rnaindel

Link to section 'Module' of 'rnaindel' Module

You can load the modules by:

module load biocontainers
module load rnaindel

Link to section 'Example job' of 'rnaindel' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RNAIndel on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rnaindel
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rnaindel

rnapeg

Link to section 'Introduction' of 'rnapeg' Introduction

RNApeg is an RNA junction calling, correction, and quality-control package. RNAIndel supports GRCh38 and 37.

For more information, please check its Github package: https://github.com/stjude/RNApeg/pkgs/container/rnapeg and its home page on Github.

Link to section 'Versions' of 'rnapeg' Versions

2.7.1

Link to section 'Commands' of 'rnapeg' Commands

RNApeg.sh

Link to section 'Module' of 'rnapeg' Module

You can load the modules by:

module load biocontainers
module load rnapeg

Link to section 'Example job' of 'rnapeg' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RNApeg on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rnapeg
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rnapeg

rnaquast

Link to section 'Introduction' of 'rnaquast' Introduction

Rnaquast is a quality assessment tool for de novo transcriptome assemblies.

For more information, please check its website: https://biocontainers.pro/tools/rnaquast and its home page: http://cab.spbu.ru/software/rnaquast/.

Link to section 'Versions' of 'rnaquast' Versions

2.2.1

Link to section 'Commands' of 'rnaquast' Commands

rnaQUAST.py

Link to section 'Dependencies de novo quality assessment and read alignment' of 'rnaquast' Dependencies de novo quality assessment and read alignment

When reference genome and gene database are unavailable, users can also use BUSCO and GeneMarkS-T in rnaQUAST pipeline. Since GeneMarkS-T requires the license key, users may need to download your own key, and put it in your $HOME.
rnaQUAST is also capable of calculating various statistics using raw reads (e.g. database coverage by reads). To use this, you will need use STAR in the pipeline. BUSCO, GeneMarkS-T, and STAR have been installed, and the directories of their executables have been added to $PATH. Users do not need to load these modules. The only module required is rnaquast itself.

Link to section 'Module' of 'rnaquast' Module

You can load the modules by:

module load biocontainers
module load rnaquast

Link to section 'Example job' of 'rnaquast' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Rnaquast on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=rnaquast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rnaquast

rnaQUAST.py -t 12 -o output \
     --transcripts Trinity.fasta idba.fasta \
     --reference Saccharomyces_cerevisiae.R64-1-1.75.dna.toplevel.fa \
     --gtf Saccharomyces_cerevisiae.R64-1-1.75.gtf

rnaQUAST.py -t 12 -o output2 \
     --reference reference.fasta \
     --transcripts transcripts.fasta \
     --left_reads lef.fastq \
     --right_reads right.fastq \
     --busco fungi_odb10

roary

Link to section 'Introduction' of 'roary' Introduction

Roary is a high speed stand alone pan genome pipeline, which takes annotated assemblies in GFF3 format (produced by Prokka) and calculates the pan genome.

Docker hub: https://hub.docker.com/r/staphb/roary
Home page: https://github.com/sanger-pathogens/Roary

Link to section 'Versions' of 'roary' Versions

3.13.0

Link to section 'Commands' of 'roary' Commands

roary

Link to section 'Module' of 'roary' Module

You can load the modules by:

module load biocontainers
module load roary

Link to section 'Example job' of 'roary' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run roary on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=roary
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers roary
    
roary -f demo -e -n -v gff/*.gff

rsem

RSEM is a software package for estimating gene and isoform expression levels from RNA-Seq data. Further information can be found here: https://deweylab.github.io/RSEM/.

Link to section 'Versions' of 'rsem' Versions

1.3.3

Commands
- rsem-bam2readdepth - rsem-bam2wig - rsem-build-read-index - rsem-calculate-credibility-intervals - rsem-calculate-expression - rsem-control-fdr - rsem-extract-reference-transcripts - rsem-generate-data-matrix - rsem-generate-ngvector - rsem-gen-transcript-plots - rsem-get-unique - rsem-gff3-to-gtf - rsem-parse-alignments - rsem-plot-model - rsem-plot-transcript-wiggles - rsem-prepare-reference - rsem-preref - rsem-refseq-extract-primary-assembly - rsem-run-ebseq - rsem-run-em - rsem-run-gibbs - rsem-run-prsem-testing-procedure - rsem-sam-validator - rsem-scan-for-paired-end-reads - rsem-simulate-reads - rsem-synthesis-reference-transcripts - rsem-tbam2gbam

Link to section 'Dependencies' of 'rsem' Dependencies

STAR v2.7.9a, Bowtie v1.2.3, Bowtie2 v2.3.5.1, HISAT2 v2.2.1 were included in the container image. So users do not need to provide the dependency path in the RSEM parameter.

Link to section 'Module' of 'rsem' Module

You can load the modules by:

module load biocontainers
module load rsem/1.3.3

Link to section 'Example job' of 'rsem' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run RSEM on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=rsem
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rsem/1.3.3

rsem-prepare-reference --gtf Homo_sapiens.GRCh38.105.gtf --bowtie Homo_sapiens.GRCh38.dna.primary_assembly.fa Gh38_bowtie  -p 24
rsem-prepare-reference --gtf Homo_sapiens.GRCh38.105.gtf --bowtie2 Homo_sapiens.GRCh38.dna.primary_assembly.fa Gh38_bowtie2  -p 24
rsem-prepare-reference --gtf Homo_sapiens.GRCh38.105.gtf --hisat2-hca  Homo_sapiens.GRCh38.dna.primary_assembly.fa Gh38_hisat2  -p 24
rsem-prepare-reference --gtf Homo_sapiens.GRCh38.105.gtf --star Homo_sapiens.GRCh38.dna.primary_assembly.fa Gh38_star  -p 24
rsem-calculate-expression --paired-end --star -p 24 SRR12095148_1.fastq SRR12095148_2.fastq  Gh38_star SRR12095148_rsem_expression

rseqc

Link to section 'Introduction' of 'rseqc' Introduction

Rseqc is a package provides a number of useful modules that can comprehensively evaluate high throughput sequence data especially RNA-seq data.

For more information, please check its website: https://biocontainers.pro/tools/rseqc and its home page: http://rseqc.sourceforge.net.

Link to section 'Versions' of 'rseqc' Versions

4.0.0

Link to section 'Module' of 'rseqc' Module

You can load the modules by:

module load biocontainers
module load rseqc

Link to section 'Example job' of 'rseqc' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Rseqc on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rseqc
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rseqc

bam_stat.py -i *.bam -q 30

run_dbcan

run_dbCAN using genomes/metagenomes/proteomes of any assembled organisms (prokaryotes, fungi, plants, animals, viruses) to search for CAZymes. This is a standalone tool of http://bcb.unl.edu/dbCAN2/. Details about its usage can be found in its Github repository.

Link to section 'Versions' of 'run_dbcan' Versions

3.0.2
3.0.6

Commands
run_dbcan

Link to section 'Database' of 'run_dbcan' Database

Latest version of database has been downloaded and setup, including CAZyDB.09242021.fa, dbCAN-HMMdb-V10.txt, tcdb.fa, tf-1.hmm, tf-2.hmm, and stp.hmm.

Link to section 'Module' of 'run_dbcan' Module

You can load the modules by:

module load biocontainers
module load run_dbcan/3.0.2

Link to section 'Example job' of 'run_dbcan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run run_dbcan on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=run_dbcan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers run_dbcan/3.0.2

run_dbcan protein.faa protein --out_dir test1_dbcan
run_dbcan genome.fasta prok --out_dir test2_dbcan

rush

Link to section 'Introduction' of 'rush' Introduction

rush is a tool similar to GNU parallel and gargs. rush borrows some idea from them and has some unique features, e.g., supporting custom defined variables, resuming multi-line commands, more advanced embedded replacement strings.

For more information, please check its home page on Github.

Link to section 'Versions' of 'rush' Versions

0.4.2

Link to section 'Commands' of 'rush' Commands

rush

Link to section 'Module' of 'rush' Module

You can load the modules by:

module load biocontainers
module load rush

Link to section 'Example job' of 'rush' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run rush on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=rush
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers rush

sage

Link to section 'Introduction' of 'sage' Introduction

Sage is a proteomics search engine - a tool that transforms raw mass spectra from proteomics experiments into peptide identifications via database searching & spectral matching. But, it's also more than just a search engine - Sage includes a variety of advanced features that make it a one-stop shop: retention time prediction, quantification (both isobaric & LFQ), peptide-spectrum match rescoring, and FDR control.

GitHub Packages: https://github.com/lazear/sage/pkgs/container/sage
Home page: https://github.com/lazear/sage

Link to section 'Versions' of 'sage' Versions

0.8.1

Link to section 'Commands' of 'sage' Commands

sage

Link to section 'Module' of 'sage' Module

You can load the modules by:

module load biocontainers
module load sage

Link to section 'Example job' of 'sage' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run sage on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sage
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sage

salmon

Salmon is a wicked-fast program to produce a highly-accurate, transcript-level quantification estimates from RNA-seq data.

Detailed usage can be found here: https://github.com/COMBINE-lab/salmon

Link to section 'Versions' of 'salmon' Versions

1.5.2
1.6.0
1.7.0
1.8.0
1.9.0

Link to section 'Commands' of 'salmon' Commands

salmon index
salmon quant
salmon alevin
salmon swim
salmon quantmerge

Link to section 'Module' of 'salmon' Module

You can load the modules by:

module load biocontainers
module load salmon

Link to section 'Example job' of 'salmon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Salmon on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=salmon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers salmon

salmon index -t  Homo_sapiens.GRCh38.cds.all.fa -i salmon_index
salmon quant -i salmon_index -l A -p 24 -1 SRR16956239_1.fastq -2 SRR16956239_2.fastq --validateMappings -o transcripts_quan

sambamba

Link to section 'Introduction' of 'sambamba' Introduction

Sambamba is a high performance highly parallel robust and fast tool (and library), written in the D programming language, for working with SAM and BAM files.

For more information, please check its website: https://biocontainers.pro/tools/sambamba and its home page on Github.

Link to section 'Versions' of 'sambamba' Versions

0.8.2

Link to section 'Commands' of 'sambamba' Commands

sambamba

Link to section 'Module' of 'sambamba' Module

You can load the modules by:

module load biocontainers
module load sambamba

Link to section 'Example job' of 'sambamba' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Sambamba on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sambamba
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sambamba

sambamba view --reference-info input.bam 
sambamba view -c -F "mapping_quality >= 40" input.bam

samblaster

Link to section 'Introduction' of 'samblaster' Introduction

Samblaster is a tool to mark duplicates and extract discordant and split reads from sam files.

For more information, please check its website: https://biocontainers.pro/tools/samblaster and its home page on Github.

Link to section 'Versions' of 'samblaster' Versions

0.1.26

Link to section 'Commands' of 'samblaster' Commands

samblaster

Link to section 'Module' of 'samblaster' Module

You can load the modules by:

module load biocontainers
module load samblaster

Link to section 'Example job' of 'samblaster' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Samblaster on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=samblaster
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers samblaster

samclip

Link to section 'Introduction' of 'samclip' Introduction

Samclip is a tool to filter SAM file for soft and hard clipped alignments.

BioContainers: https://biocontainers.pro/tools/samclip
Home page: https://github.com/tseemann/samclip

Link to section 'Versions' of 'samclip' Versions

0.4.0

Link to section 'Commands' of 'samclip' Commands

samclip

Link to section 'Module' of 'samclip' Module

You can load the modules by:

module load biocontainers
module load samclip

Link to section 'Example job' of 'samclip' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run samclip on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=samclip
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers samclip

samclip --ref test.fna < test.sam > out.sam

samplot

Link to section 'Introduction' of 'samplot' Introduction

Samplot is a command line tool for rapid, multi-sample structural variant visualization.

For more information, please check its website: https://biocontainers.pro/tools/samplot and its home page on Github.

Link to section 'Versions' of 'samplot' Versions

1.3.0

Link to section 'Commands' of 'samplot' Commands

samplot

Link to section 'Module' of 'samplot' Module

You can load the modules by:

module load biocontainers
module load samplot

Link to section 'Example job' of 'samplot' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Samplot on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=samplot
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers samplot

samplot plot \
-n NA12878 NA12889 NA12890 \
-b samplot/test/data/NA12878_restricted.bam \
  samplot/test/data/NA12889_restricted.bam \
  samplot/test/data/NA12890_restricted.bam \
-o 4_115928726_115931880.png \
-c chr4 \
-s 115928726 \
-e 115931880 \
-t DEL

samtools

Link to section 'Introduction' of 'samtools' Introduction

Samtools is a set of utilities for the Sequence Alignment/Map (SAM) format.

For more information, please check its website: https://biocontainers.pro/tools/samtools and its home page on Github.

Link to section 'Versions' of 'samtools' Versions

1.15
1.16
1.17
1.9

Link to section 'Commands' of 'samtools' Commands

samtools
ace2sam
htsfile
maq2sam-long
maq2sam-short
tabix
wgsim

Link to section 'Module' of 'samtools' Module

You can load the modules by:

module load biocontainers
module load samtools

Link to section 'Example job' of 'samtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Samtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=samtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers samtools

samtools sort my.sam > my_sorted.bam
samtools index my_sorted.bam

scanpy

Scanpy is scalable toolkit for analyzing single-cell gene expression data. It includes preprocessing, visualization, clustering, pseudotime and trajectory inference and differential expression testing. The Python-based implementation efficiently deals with datasets of more than one million cells. Details about its usage can be found here (https://scanpy.readthedocs.io/en/stable/)

Link to section 'Versions' of 'scanpy' Versions

1.8.2
1.9.1

Link to section 'Commands' of 'scanpy' Commands

python
python3

Link to section 'Module' of 'scanpy' Module

You can load the modules by:

module load biocontainers  
module load scanpy/1.8.2

Link to section 'Interactive job' of 'scanpy' Interactive job

To run scanpy interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers scanpy/1.8.2
(base) UserID@bell-a008:~ $ python
Python 3.9.5 (default, Jun  4 2021, 12:28:51)  
[GCC 7.5.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import scanpy as sc
>>> sc.tl.umap(adata, **tool_params)

Link to section 'Batch job' of 'scanpy' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=scanpy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scanpy/1.8.2 

python script.py

scarches

Link to section 'Introduction' of 'scarches' Introduction

scArches is a package to integrate newly produced single-cell datasets into integrated reference atlases.

Home page: https://github.com/theislab/scarches

Link to section 'Versions' of 'scarches' Versions

0.5.3

Link to section 'Commands' of 'scarches' Commands

python
python3

Link to section 'Module' of 'scarches' Module

You can load the modules by:

module load biocontainers
module load scarches

Link to section 'Example job' of 'scarches' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run scarches on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=scarches
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scarches

scgen

Link to section 'Introduction' of 'scgen' Introduction

scGen is a generative model to predict single-cell perturbation response across cell types, studies and species.

Home page: https://github.com/theislab/scgen

Link to section 'Versions' of 'scgen' Versions

2.1.0

Link to section 'Commands' of 'scgen' Commands

python
python3

Link to section 'Module' of 'scgen' Module

You can load the modules by:

module load biocontainers
module load scgen

Link to section 'Example job' of 'scgen' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run scgen on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=scgen
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scgen

scirpy

Link to section 'Introduction' of 'scirpy' Introduction

Scirpy is a scalable python-toolkit to analyse T cell receptor (TCR) or B cell receptor (BCR) repertoires from single-cell RNA sequencing (scRNA-seq) data. It seamlessly integrates with the popular scanpy library and provides various modules for data import, analysis and visualization.

Home page: https://github.com/scverse/scirpy

Link to section 'Versions' of 'scirpy' Versions

0.10.1

Link to section 'Commands' of 'scirpy' Commands

python
python3

Link to section 'Module' of 'scirpy' Module

You can load the modules by:

module load biocontainers
module load scirpy

Link to section 'Example job' of 'scirpy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run scirpy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=scirpy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scirpy

scvelo

scVelo is a scalable toolkit for RNA velocity analysis in single cells, based on https://doi.org/10.1038/s41587-020-0591-3. Its detailed usage can be found here: https://scvelo.readthedocs.io.

Link to section 'Versions' of 'scvelo' Versions

0.2.4

Link to section 'Commands' of 'scvelo' Commands

python
python3

Link to section 'Module' of 'scvelo' Module

You can load the modules by:

module load biocontainers  
module load scvelo/0.2.4

Link to section 'Interactive job' of 'scvelo' Interactive job

To run scVelo interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers scvelo/0.2.4
(base) UserID@bell-a008:~ $ python
Python 3.9.5 (default, Jun  4 2021, 12:28:51)  
[GCC 7.5.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import scvelo as scv
>>> scv.set_figure_params()

Link to section 'Batch job' of 'scvelo' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=scvelo
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scvelo/0.2.4 

python script.py

scvi-tools

Link to section 'Introduction' of 'scvi-tools' Introduction

scvi-tools (single-cell variational inference tools) is a package for end-to-end analysis of single-cell omics data primarily developed and maintained by the Yosef Lab at UC Berkeley.

Home page: https://scvi-tools.org

Link to section 'Versions' of 'scvi-tools' Versions

0.16.2

Link to section 'Commands' of 'scvi-tools' Commands

python
python3
R
Rscript

Link to section 'Module' of 'scvi-tools' Module

You can load the modules by:

module load biocontainers
module load scvi-tools

Link to section 'Example job' of 'scvi-tools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run scvi-tools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=scvi-tools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers scvi-tools

segalign

Link to section 'Introduction' of 'segalign' Introduction

Segalign is a scalable GPU system for pairwise whole genome alignments based on LASTZ's seed-filter-extend paradigm.

Docker hub: https://hub.docker.com/r/gsneha/segalign
Home page: https://github.com/gsneha26/SegAlign

Link to section 'Versions' of 'segalign' Versions

0.1.2

Link to section 'Commands' of 'segalign' Commands

faToTwoBit
run_segalign
run_segalign_repeat_masker
segalign
segalign_repeat_masker
twoBitToFa

Link to section 'Module' of 'segalign' Module

You can load the modules by:

module load biocontainers
module load segalign

Link to section 'Example job' of 'segalign' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run segalign on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=segalign
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers segalign

seidr

Link to section 'Introduction' of 'seidr' Introduction

Seidr is a community gene network inference and exploration toolkit.

For more information, please check its website: https://biocontainers.pro/tools/seidr and its home page on Github.

Link to section 'Versions' of 'seidr' Versions

0.14.2

Link to section 'Module' of 'seidr' Module

You can load the modules by:

module load biocontainers
module load seidr

Link to section 'Example job' of 'seidr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Seidr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=seidr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers seidr

sepp

Link to section 'Introduction' of 'sepp' Introduction

Sepp stands for SATé-Enabled Phylogenetic Placement and addresses the problem of phylogenetic placement for meta-genomic short reads.

For more information, please check its website: https://biocontainers.pro/tools/sepp and its home page on Github.

Link to section 'Versions' of 'sepp' Versions

4.5.1

Link to section 'Commands' of 'sepp' Commands

run_sepp.py
run_upp.py
split_sequences.py
sumlabels.py
sumtrees.py

Link to section 'Module' of 'sepp' Module

You can load the modules by:

module load biocontainers
module load sepp

Link to section 'Example job' of 'sepp' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Sepp on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sepp
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sepp

run_sepp.py -t mock/rpsS/sate.tre \
    -r mock/rpsS/sate.tre.RAxML_info \
    -a mock/rpsS/sate.fasta \
    -f mock/rpsS/rpsS.even.fas \
    -o rpsS.out.default

seqcode

Link to section 'Introduction' of 'seqcode' Introduction

SeqCode is a family of applications designed to develop high-quality images and perform genome-wide calculations from high-throughput sequencing experiments. This software is presented into two distinct modes: web tools and command line. The website of SeqCode offers most functions to users with no previous expertise in bioinformatics, including operations on a selection of published ChIP-seq samples and applications to generate multiple classes of graphics from data files of the user. On the contrary, the standalone version of SeqCode allows bioinformaticians to run each command on any type of sequencing data locally in their computer. The architecture of the source code is modular and the input/output interface of the commands is suitable to be integrated into existing pipelines of genome analysis. SeqCode has been written in ANSI C, which favors the compatibility in every UNIX platform and grants a high performance and speed when analyzing sequencing data. Meta-plots, heatmaps, boxplots and the rest of images produced by SeqCode are internally generated using R. SeqCode relies on the RefSeq reference annotations and is able to deal with the genome and assembly release of every organism that is available from this consortium.

Docker hub: https://hub.docker.com/r/eblancocrg/seqcode
Home page: https://github.com/eblancoga/seqcode

Link to section 'Versions' of 'seqcode' Versions

Link to section 'Module' of 'seqcode' Module

You can load the modules by:

module load biocontainers
module load seqcode

Link to section 'Example job' of 'seqcode' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run seqcode on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=seqcode
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers seqcode

buildChIPprofile -vd ChromInfo.txt \
     H3K4me3_sample.bam test_buildChIPprofile

seqkit

Link to section 'Introduction' of 'seqkit' Introduction

Seqkit is a rapid tool for manipulating fasta and fastq files.

For more information, please check its website: https://biocontainers.pro/tools/seqkit and its home page on Github.

Link to section 'Versions' of 'seqkit' Versions

2.0.0
2.1.0
2.3.1

Link to section 'Commands' of 'seqkit' Commands

seqkit

Link to section 'Module' of 'seqkit' Module

You can load the modules by:

module load biocontainers
module load seqkit

Link to section 'Example job' of 'seqkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Seqkit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=seqkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers seqkit

seqkit stats configs.fasta > contigs_statistics.txt

seqyclean

Link to section 'Introduction' of 'seqyclean' Introduction

Seqyclean is used to pre-process NGS data in order to prepare for downstream analysis. For more information, please check: Docker hub: https://hub.docker.com/r/staphb/seqyclean
Home page: https://github.com/ibest/seqyclean

Link to section 'Versions' of 'seqyclean' Versions

1.10.09

Link to section 'Commands' of 'seqyclean' Commands

seqyclean

Link to section 'Module' of 'seqyclean' Module

You can load the modules by:

module load biocontainers
module load seqyclean

Link to section 'Example job' of 'seqyclean' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run seqyclean on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=seqyclean
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers seqyclean

shapeit4

Link to section 'Introduction' of 'shapeit4' Introduction

SHAPEIT4 is a fast and accurate method for estimation of haplotypes (aka phasing) for SNP array and high coverage sequencing data.

BioContainers: https://biocontainers.pro/tools/shapeit4
Home page: https://odelaneau.github.io/shapeit4/

Link to section 'Versions' of 'shapeit4' Versions

4.2.2

Link to section 'Commands' of 'shapeit4' Commands

shapeit4

Link to section 'Module' of 'shapeit4' Module

You can load the modules by:

module load biocontainers
module load shapeit4

Link to section 'Example job' of 'shapeit4' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run shapeit4 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shapeit4
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shapeit4

shapeit5

Link to section 'Introduction' of 'shapeit5' Introduction

SHAPEIT5 is a software package to estimate haplotypes in large genotype datasets (WGS and SNP array).

Home page: https://github.com/odelaneau/shapeit5

Link to section 'Versions' of 'shapeit5' Versions

5.1.1

Link to section 'Commands' of 'shapeit5' Commands

phase_common
ligate
phase_rare
simulate
switch
xcftools

Link to section 'Module' of 'shapeit5' Module

You can load the modules by:

module load biocontainers
module load shapeit5

Link to section 'Example job' of 'shapeit5' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run shapeit5 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shapeit5
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shapeit5

phase_common --input wgs/target.unrelated.bcf --filter-maf 0.001 --region 1 --map info/chr1.gmap.gz --output tmp/target.scaffold.bcf --thread 8

shasta

Link to section 'Introduction' of 'shasta' Introduction

Shasta is a software for de novo assembly from Oxford Nanopore reads.

Home page: https://github.com/chanzuckerberg/shasta

Link to section 'Versions' of 'shasta' Versions

0.10.0

Link to section 'Commands' of 'shasta' Commands

shasta

Link to section 'Module' of 'shasta' Module

You can load the modules by:

module load biocontainers
module load shasta

Link to section 'Example job' of 'shasta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run shasta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shasta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shasta

shasta --input r94_ec_rad2.181119.60x-10kb.fasta \
    --config Nanopore-May2022

shigeifinder

Link to section 'Introduction' of 'shigeifinder' Introduction

Shigeifinder is a tool that is used to identify differentiate Shigella/EIEC using cluster-specific genes and identify the serotype using O-antigen/H-antigen genes. For more information, please check: Docker hub: https://hub.docker.com/r/staphb/shigeifinder
Home page: https://github.com/LanLab/ShigEiFinder

Link to section 'Versions' of 'shigeifinder' Versions

1.3.2

Link to section 'Commands' of 'shigeifinder' Commands

shigeifinder

Link to section 'Module' of 'shigeifinder' Module

You can load the modules by:

module load biocontainers
module load shigeifinder

Link to section 'Example job' of 'shigeifinder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run shigeifinder on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shigeifinder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shigeifinder

shorah

Link to section 'Introduction' of 'shorah' Introduction

Shorah is an open source project for the analysis of next generation sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/shorah and its home page on Github.

Link to section 'Versions' of 'shorah' Versions

1.99.2

Link to section 'Commands' of 'shorah' Commands

shorah
b2w
diri_sampler
fil

Link to section 'Module' of 'shorah' Module

You can load the modules by:

module load biocontainers
module load shorah

Link to section 'Example job' of 'shorah' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Shorah on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shorah
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shorah

shorah amplicon -b ampli_sorted.bam -f reference.fasta
shorah shotgun -b test_aln.cram -f test_ref.fasta
shorah shotgun -a 0.1 -w 42 -x 100000 -p 0.9 -c 0 -r REF:42-272 -R 42 -b test_aln.cram -f ref.fasta

shortstack

Link to section 'Introduction' of 'shortstack' Introduction

Shortstack is a tool for comprehensive annotation and quantification of small RNA genes.

For more information, please check its website: https://biocontainers.pro/tools/shortstack and its home page on Github.

Link to section 'Versions' of 'shortstack' Versions

3.8.5

Link to section 'Commands' of 'shortstack' Commands

ShortStack

Link to section 'Module' of 'shortstack' Module

You can load the modules by:

module load biocontainers
module load shortstack

Link to section 'Example job' of 'shortstack' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Shortstack on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shortstack
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shortstack

shovill

Link to section 'Introduction' of 'shovill' Introduction

Shovill is a tool to assemble bacterial isolate genomes from Illumina paired-end reads.

Docker hub: https://hub.docker.com/r/staphb/shovill
Home page: https://github.com/tseemann/shovill

Link to section 'Versions' of 'shovill' Versions

1.1.0

Link to section 'Commands' of 'shovill' Commands

shovill

Link to section 'Module' of 'shovill' Module

You can load the modules by:

module load biocontainers
module load shovill

Link to section 'Example job' of 'shovill' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run shovill on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=shovill
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers shovill

shovill --outdir out \
    --R1 test/R1.fq.gz \
    --R2 test/R2.fq.gz

sicer

Link to section 'Introduction' of 'sicer' Introduction

Sicer is a clustering approach for identification of enriched domains from histone modification ChIP-Seq data.

For more information, please check its website: https://biocontainers.pro/tools/sicer and its home page: http://home.gwu.edu/~wpeng/Software.htm.

Link to section 'Versions' of 'sicer' Versions

Link to section 'Commands' of 'sicer' Commands

SICER-df-rb.sh
SICER-df.sh
SICER-rb.sh
SICER.sh

Link to section 'Module' of 'sicer' Module

You can load the modules by:

module load biocontainers
module load sicer

Link to section 'Example job' of 'sicer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Sicer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sicer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sicer

SICER.sh ./ test.bed control.bed . hg18 1 200 150 0.74 600 .01

SICER-rb.sh ./ test.bed . hg18 1 200 150 0.74 400 100

sicer2

Link to section 'Introduction' of 'sicer2' Introduction

Sicer2 is the redesigned and improved ChIP-seq broad peak calling tool SICER.

For more information, please check its website: https://biocontainers.pro/tools/sicer2 and its home page on Github.

Link to section 'Versions' of 'sicer2' Versions

1.0.3
1.2.0

Link to section 'Commands' of 'sicer2' Commands

sicer
sicer_df
recognicer
recognicer_df

Link to section 'Module' of 'sicer2' Module

You can load the modules by:

module load biocontainers
module load sicer2

Link to section 'Example job' of 'sicer2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Sicer2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sicer2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sicer2

sicer_df -t ./test/treatment_1.bed ./test/treatment_2.bed \ 
    -c ./test/control_1.bed ./test/control_2.bed \
    -s hg38 --significant_reads

recognicer_df -t ./test/treatment_1.bed ./test/treatment_2.bed \
    -c ./test/control_1.bed ./test/control_2.bed \
    -s hg38 --significant_reads

signalp4

Link to section 'Introduction' of 'signalp4' Introduction

SignalP predicts the presence and location of signal peptide cleavage sites in amino acid sequences from different organisms: Gram-positive prokaryotes, Gram-negative prokaryotes, and eukaryotes.

For more information, please check its home page: https://services.healthtech.dtu.dk/service.php?SignalP-4.1.

Link to section 'Versions' of 'signalp4' Versions

Link to section 'Commands' of 'signalp4' Commands

signalp

Link to section 'Module' of 'signalp4' Module

You can load the modules by:

module load biocontainers
module load signalp

Link to section 'Example job' of 'signalp4' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run SignalP on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=signalp
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers signalp

signalp -t gram+ -f all proka.fasta > proka_out
signalp -t euk -f all euk.fasta > euk.out

signalp6

Link to section 'Introduction' of 'signalp6' Introduction

SignalP predicts the presence and location of signal peptide cleavage sites in amino acid sequences from different organisms: Gram-positive prokaryotes, Gram-negative prokaryotes, and eukaryotes.

Home page: https://services.healthtech.dtu.dk/service.php?SignalP

Link to section 'Versions' of 'signalp6' Versions

6.0-fast
6.0-slow

Link to section 'Commands' of 'signalp6' Commands

signalp6

Link to section 'Module' of 'signalp6' Module

You can load the modules by:

module load biocontainers
module load signalp6

Link to section 'Example job for fast mode' of 'signalp6' Example job for fast mode

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run signalp6 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 2:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=signalp6-fast
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers signalp6/6.0-fast

signalp6 --write_procs 24 --fastafile proteins_clean.fasta  \
    --organism euk --output_dir output_fast  \
    --format txt --mode fast

Link to section 'Example job for slow mode' of 'signalp6' Example job for slow mode

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run signalp6 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 12:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=signalp6-slow
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers signalp6/6.0-slow

signalp6 --write_procs 24 --fastafile proteins_clean.fasta  \
    --organism euk --output_dir output_slow  \
    --format txt --mode slow

signalp6 --write_procs 24 --fastafile proteins_clean.fasta  \
    --organism euk --output_dir output_slow-sequential  \
    --format txt --mode slow-sequential

simug

Link to section 'Introduction' of 'simug' Introduction

Simug is a general-purpose genome simulator.

For more information, please check its website: https://biocontainers.pro/tools/simug and its home page on Github.

Link to section 'Versions' of 'simug' Versions

1.0.0

Link to section 'Commands' of 'simug' Commands

simuG
vcf2model

Link to section 'Module' of 'simug' Module

You can load the modules by:

module load biocontainers
module load simug

Link to section 'Example job' of 'simug' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Simug on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=simug
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers simug

singlem

Link to section 'Introduction' of 'singlem' Introduction

SingleM is a tool for profiling shotgun metagenomes. It has a particular strength in detecting microbial lineages which are not in reference databases. The method it uses also makes it suitable for some related tasks, such as assessing eukaryotic contamination, finding bias in genome recovery, computing ecological diversity metrics, and lineage-targeted MAG recovery.

Docker hub: https://hub.docker.com/r/wwood/singlem
Home page: https://github.com/wwood/singlem

Link to section 'Versions' of 'singlem' Versions

0.13.2

Link to section 'Commands' of 'singlem' Commands

singlem

Link to section 'Module' of 'singlem' Module

You can load the modules by:

module load biocontainers
module load singlem

Link to section 'Example job' of 'singlem' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run singlem on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=singlem
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers singlem

ska

Link to section 'Introduction' of 'ska' Introduction

SKA (Split Kmer Analysis) is a toolkit for prokaryotic (and any other small, haploid) DNA sequence analysis using split kmers. A split kmer is a pair of kmers in a DNA sequence that are separated by a single base. Split kmers allow rapid comparison and alignment of small genomes, and is particularly suited for surveillance or outbreak investigation. SKA can produce split kmer files from fasta format assemblies or directly from fastq format read sequences, cluster them, align them with or without a reference sequence and provide various comparison and summary statistics. Currently all testing has been carried out on high-quality Illumina read data, so results for other platforms may vary.

Docker hub: https://hub.docker.com/r/staphb/ska
Home page: https://github.com/simonrharris/SKA

Link to section 'Versions' of 'ska' Versions

Link to section 'Commands' of 'ska' Commands

Link to section 'Module' of 'ska' Module

You can load the modules by:

module load biocontainers
module load ska

Link to section 'Example job' of 'ska' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run ska on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=ska
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ska

skewer

Link to section 'Introduction' of 'skewer' Introduction

Skewer is a fast and accurate adapter trimmer for paired-end reads.

For more information, please check its website: https://biocontainers.pro/tools/skewer and its home page on Github.

Link to section 'Versions' of 'skewer' Versions

0.2.2

Link to section 'Commands' of 'skewer' Commands

skewer

Link to section 'Module' of 'skewer' Module

You can load the modules by:

module load biocontainers
module load skewer

Link to section 'Example job' of 'skewer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Skewer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=skewer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers skewer

skewer -l 50 -m pe -o skewerQ30 --mean-quality 30 \
     --end-quality 30 -t 10 -x TruSeq3-PE.fa \
     input_1.fastq input_2.fastq

slamdunk

Link to section 'Introduction' of 'slamdunk' Introduction

Slamdunk is a novel, fully automated software tool for automated, robust, scalable and reproducible SLAMseq data analysis.

Docker hub: https://hub.docker.com/r/tobneu/slamdunk
Home page: http://t-neumann.github.io/slamdunk/

Link to section 'Versions' of 'slamdunk' Versions

0.4.3

Link to section 'Commands' of 'slamdunk' Commands

slamdunk
alleyoop

Link to section 'Module' of 'slamdunk' Module

You can load the modules by:

module load biocontainers
module load slamdunk

Link to section 'Example job' of 'slamdunk' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run slamdunk on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=slamdunk
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers slamdunk

smoove

Link to section 'Introduction' of 'smoove' Introduction

Smoove simplifies and speeds calling and genotyping SVs for short reads.

For more information, please check its website: https://biocontainers.pro/tools/smoove and its home page on Github.

Link to section 'Versions' of 'smoove' Versions

0.2.7

Link to section 'Commands' of 'smoove' Commands

smoove

Link to section 'Module' of 'smoove' Module

You can load the modules by:

module load biocontainers
module load smoove

Link to section 'Example job' of 'smoove' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Smoove on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=smoove
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers smoove

smoove call \
    -x --name my-cohort \
    --exclude hg38_blacklist.bed \
    --fasta  Homo_sapiens.GRCh38.dna.primary_assembly.fa \
     -p 24 \
    --genotype input_bams/*.bam

snakemake

Link to section 'Introduction' of 'snakemake' Introduction

Snakemake is a workflow engine that provides a readable Python-based workflow definition language and a powerful execution environment that scales from single-core workstations to compute clusters without modifying the workflow.

For more information, please check its website: https://biocontainers.pro/tools/snakemake and its home page: https://snakemake.readthedocs.io/en/stable/.

Link to section 'Versions' of 'snakemake' Versions

6.8.0

Link to section 'Commands' of 'snakemake' Commands

snakemake

Link to section 'Module' of 'snakemake' Module

You can load the modules by:

module load biocontainers
module load snakemake

Link to section 'Example job' of 'snakemake' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snakemake on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snakemake
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snakemake

snap

Link to section 'Introduction' of 'snap' Introduction

Snap is a semi-HMM-based Nucleic Acid Parser -- gene prediction tool.

For more information, please check its website: https://biocontainers.pro/tools/snap and its home page: http://korflab.ucdavis.edu/software.html.

Link to section 'Versions' of 'snap' Versions

2013_11_29

Link to section 'Commands' of 'snap' Commands

snap

Link to section 'Module' of 'snap' Module

You can load the modules by:

module load biocontainers
module load snap

Link to section 'Example job' of 'snap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snap

snap-aligner

Link to section 'Introduction' of 'snap-aligner' Introduction

Snap-aligner (Scalable Nucleotide Alignment Program) is a fast and accurate read aligner for high-throughput sequencing data.

For more information, please check its website: https://biocontainers.pro/tools/snap-aligner and its home page: http://snap.cs.berkeley.edu/.

Link to section 'Versions' of 'snap-aligner' Versions

2.0.0

Link to section 'Commands' of 'snap-aligner' Commands

snap-aligner

Link to section 'Module' of 'snap-aligner' Module

You can load the modules by:

module load biocontainers
module load snap-aligner

Link to section 'Example job' of 'snap-aligner' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snap-aligner on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snap-aligner
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snap-aligner

snaptools

Link to section 'Introduction' of 'snaptools' Introduction

Snaptools is a python module for pre-processing and working with snap file.

For more information, please check its website: https://biocontainers.pro/tools/snaptools and its home page on Github.

Link to section 'Versions' of 'snaptools' Versions

1.4.8

Link to section 'Commands' of 'snaptools' Commands

snaptools

Link to section 'Module' of 'snaptools' Module

You can load the modules by:

module load biocontainers
module load snaptools

Link to section 'Example job' of 'snaptools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snaptools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snaptools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snaptools

snippy

Link to section 'Introduction' of 'snippy' Introduction

Snippy is a tool for rapid haploid variant calling and core genome alignment.

Docker hub: https://hub.docker.com/r/staphb/snippy and its home page on Github.

Link to section 'Versions' of 'snippy' Versions

4.6.0

Link to section 'Commands' of 'snippy' Commands

snippy
snippy-clean_full_aln
snippy-core
snippy-multi
snippy-vcf_extract_subs
snippy-vcf_report
snippy-vcf_to_tab

Link to section 'Module' of 'snippy' Module

You can load the modules by:

module load biocontainers
module load snippy

Link to section 'Example job' of 'snippy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snippy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snippy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snippy

snp-dists

Link to section 'Introduction' of 'snp-dists' Introduction

Snp-dists is a tool to convert a FASTA alignment to SNP distance matrix.

Docker hub: https://hub.docker.com/r/staphb/snp-dists
Home page: https://github.com/tseemann/snp-dists

Link to section 'Versions' of 'snp-dists' Versions

0.8.2

Link to section 'Commands' of 'snp-dists' Commands

snp-dists

Link to section 'Module' of 'snp-dists' Module

You can load the modules by:

module load biocontainers
module load snp-dists

Link to section 'Example job' of 'snp-dists' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run snp-dists on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snp-dists
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snp-dists

snp-dists test/good.aln > distances.tab

snp-sites

Link to section 'Introduction' of 'snp-sites' Introduction

SNP-sites is a tool that apidly extracts SNPs from a multi-FASTA alignment.

Docker hub: https://hub.docker.com/r/staphb/snp-sites
Home page: https://github.com/sanger-pathogens/snp-sites

Link to section 'Versions' of 'snp-sites' Versions

2.5.1

Link to section 'Commands' of 'snp-sites' Commands

snp-sites

Link to section 'Module' of 'snp-sites' Module

You can load the modules by:

module load biocontainers
module load snp-sites

Link to section 'Example job' of 'snp-sites' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run snp-sites on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snp-sites
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snp-sites

snp-sites salmonella_serovars_core_genes.aln

snpeff

Link to section 'Introduction' of 'snpeff' Introduction

Snpeff is an open source tool that annotates variants and predicts their effects on genes by using an interval forest approach.

For more information, please check its website: https://biocontainers.pro/tools/snpeff and its home page on Github.

Link to section 'Versions' of 'snpeff' Versions

5.1d
5.1

Link to section 'Commands' of 'snpeff' Commands

snpEff

Link to section 'Module' of 'snpeff' Module

You can load the modules by:

module load biocontainers
module load snpeff

Link to section 'Example job' of 'snpeff' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

By default, snpEff only uses 1gb of memory. To allocate larger memory, add -Xmx flag in your command.:

snpeff -Xmx10g ## To allocate 10gb of memory.

To run Snpeff on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snpeff
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snpeff

snpEff GRCh37.75 examples/test.chr22.vcf > test.chr22.ann.vcf

snpgenie

Link to section 'Introduction' of 'snpgenie' Introduction

Snpgenie is a collection of Perl scripts for estimating πN/πS, dN/dS, and gene diversity from next-generation sequencing (NGS) single-nucleotide polymorphism (SNP) variant data.

For more information, please check its website: https://biocontainers.pro/tools/snpgenie and its home page on Github.

Link to section 'Versions' of 'snpgenie' Versions

Link to section 'Module' of 'snpgenie' Module

You can load the modules by:

module load biocontainers
module load snpgenie

Link to section 'Example job' of 'snpgenie' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snpgenie on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snpgenie
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snpgenie

snpgenie.pl --minfreq=0.01 --snpreport=CLC_SNP_EXAMPLE.txt \
    --fastafile=REFERENCE_EXAMPLE.fasta --gtffile=CDS_EXAMPLE.gtf

snphylo

Link to section 'Introduction' of 'snphylo' Introduction

Snphylo is a pipeline to generate a phylogenetic tree from huge SNP data.

Docker hub: https://hub.docker.com/r/finchnsnps/snphylo
Home page: https://github.com/thlee/SNPhylo

Link to section 'Versions' of 'snphylo' Versions

20180901

Link to section 'Module' of 'snphylo' Module

You can load the modules by:

module load biocontainers
module load snphylo

Link to section 'Example job' of 'snphylo' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run snphylo on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snphylo
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snphylo

snpsift

Link to section 'Introduction' of 'snpsift' Introduction

Snpsift is a tool used to annotate genomic variants using databases, filters, and manipulates genomic annotated variants.

For more information, please check its website: https://biocontainers.pro/tools/snpsift and its home page on Github.

Link to section 'Versions' of 'snpsift' Versions

4.3.1t

Link to section 'Commands' of 'snpsift' Commands

SnpSift

Link to section 'Module' of 'snpsift' Module

You can load the modules by:

module load biocontainers
module load snpsift

Link to section 'Example job' of 'snpsift' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Snpsift on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=snpsift
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers snpsift

SnpSift annotate -id dbSnp132.vcf \
    variants.vcf > variants_annotated.vcf

soapdenovo2

Link to section 'Introduction' of 'soapdenovo2' Introduction

Soapdenovo2 is a short-read assembly method to build de novo draft assembly.

For more information, please check its website: https://biocontainers.pro/tools/soapdenovo2.

Link to section 'Versions' of 'soapdenovo2' Versions

2.40

Link to section 'Commands' of 'soapdenovo2' Commands

SOAPdenovo-127mer
SOAPdenovo-63mer

Link to section 'Module' of 'soapdenovo2' Module

You can load the modules by:

module load biocontainers
module load soapdenovo2

Link to section 'Example job' of 'soapdenovo2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Soapdenovo2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=soapdenovo2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers soapdenovo2

SOAPdenovo-127mer all -s config_file -K 63 -R -o graph_prefix 1>ass.log 2>ass.err

sortmerna

Link to section 'Introduction' of 'sortmerna' Introduction

SortMeRNA is a local sequence alignment tool for filtering, mapping and clustering.

For more information, please check its website: https://biocontainers.pro/tools/sortmerna and its home page on Github.

Link to section 'Versions' of 'sortmerna' Versions

2.1b
4.3.4

Link to section 'Commands' of 'sortmerna' Commands

sortmerna

Link to section 'Module' of 'sortmerna' Module

You can load the modules by:

module load biocontainers
module load sortmerna

Link to section 'Example job' of 'sortmerna' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run SortMeRNA on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sortmerna
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sortmerna

sortmerna --ref silva-bac-16s-id90.fasta,silva-bac-16s-db \
    --reads set2_environmental_study_550_amplicon.fasta \
    --fastx --aligned Test

souporcell

Link to section 'Introduction' of 'souporcell' Introduction

souporcell is a method for clustering mixed-genotype scRNAseq experiments by individual.

Home page: https://github.com/wheaton5/souporcell

Link to section 'Versions' of 'souporcell' Versions

Link to section 'Module' of 'souporcell' Module

You can load the modules by:

module load biocontainers
module load souporcell

Link to section 'Example job' of 'souporcell' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run souporcell on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=souporcell
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers souporcell

souporcell_pipeline.py -i A.merged.bam \
    -b GSM2560245_barcodes.tsv \
    -f refdata-cellranger-GRCh38-3.0.0/fasta/genome.fa \
    -t 8 -o demux_data_test -k 4

sourmash

Link to section 'Introduction' of 'sourmash' Introduction

Sourmash is a tool for quickly search, compare, and analyze genomic and metagenomic data sets.

For more information, please check its website: https://biocontainers.pro/tools/sourmash and its home page on Github.

Link to section 'Versions' of 'sourmash' Versions

4.3.0
4.5.0

Link to section 'Commands' of 'sourmash' Commands

sourmash

Link to section 'Module' of 'sourmash' Module

You can load the modules by:

module load biocontainers
module load sourmash

Link to section 'Example job' of 'sourmash' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Sourmash on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sourmash
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sourmash

sourmash sketch dna -p k=31 *.fna.gz
sourmash compare *.sig -o cmp.dist
sourmash plot cmp.dist --labels

spaceranger

Link to section 'Introduction' of 'spaceranger' Introduction

Spaceranger is a set of analysis pipelines that process Visium Spatial Gene Expression data with brightfield and fluorescence microscope images.

Docker hub: https://hub.docker.com/r/cumulusprod/spaceranger/tags and its home page: https://support.10xgenomics.com/spatial-gene-expression/software/pipelines/latest/what-is-space-ranger.

Link to section 'Versions' of 'spaceranger' Versions

1.3.0
1.3.1
2.0.0

Link to section 'Commands' of 'spaceranger' Commands

spaceranger

Link to section 'Module' of 'spaceranger' Module

You can load the modules by:

module load biocontainers
module load spaceranger

Link to section 'Example job' of 'spaceranger' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Spaceranger on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=spaceranger
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers spaceranger

spaceranger count --id=sample345 \ #Output directory
               --transcriptome=/opt/refdata/GRCh38-2020-A \ #Path to Reference
               --fastqs=/home/jdoe/runs/HAWT7ADXX/outs/fastq_path \ #Path to FASTQs
               --sample=mysample \ #Sample name from FASTQ filename
               --image=/home/jdoe/runs/images/sample345.tiff \ #Path to brightfield image 
               --slide=V19J01-123 \ #Slide ID
               --area=A1 \ #Capture area
               --localcores=8 \ #Allowed cores in localmode
               --localmem=64 #Allowed memory (GB) in localmode

spades

SPAdes- St. Petersburg genome assembler - is an assembly toolkit containing various assembly pipelines.

Detailed usage can be found here: https://github.com/ablab/spades

Link to section 'Versions' of 'spades' Versions

3.15.3
3.15.4
3.15.5

Link to section 'Module' of 'spades' Module

You can load the modules by:

module load biocontainers
module load spades

Link to section 'Example job' of 'spades' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run spades on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=spades
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers spades

spades.py --pe1-1 SRR11234553_1.fastq --pe1-2 SRR11234553_2.fastq -o spades_out -t 24

sprod

Link to section 'Introduction' of 'sprod' Introduction

Sprod: De-noising Spatially Resolved Transcriptomics Data Based on Position and Image Information.

Home page: https://github.com/yunguan-wang/SPROD

Link to section 'Versions' of 'sprod' Versions

Link to section 'Commands' of 'sprod' Commands

python
python3
sprod.py

Link to section 'Module' of 'sprod' Module

You can load the modules by:

module load biocontainers
module load sprod

Link to section 'Example job' of 'sprod' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run sprod on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=sprod
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers sprod

python3 test_examples.py

squeezemeta

Link to section 'Introduction' of 'squeezemeta' Introduction

SqueezeMeta is a fully automated metagenomics pipeline, from reads to bins.

Home page: https://github.com/jtamames/SqueezeMeta

Link to section 'Versions' of 'squeezemeta' Versions

1.5.1

Link to section 'Module' of 'squeezemeta' Module

You can load the modules by:

module load biocontainers
module load squeezemeta

Link to section 'Example job' of 'squeezemeta' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run squeezemeta on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=squeezemeta
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers squeezemeta

SqueezeMeta.pl -m coassembly -p Hadza -s test.samples -f raw

squid

Link to section 'Introduction' of 'squid' Introduction

SQUID is designed to detect both fusion-gene and non-fusion-gene transcriptomic structural variations from RNA-seq alignment.

Home page: https://github.com/Kingsford-Group/squid

Link to section 'Versions' of 'squid' Versions

Link to section 'Commands' of 'squid' Commands

squid
AnnotateSQUIDOutput.py

Link to section 'Module' of 'squid' Module

You can load the modules by:

module load biocontainers
module load squid

Link to section 'Example job' of 'squid' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run squid on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=squid
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers squid

sra-tools

SRA-Toolkit is a collection of tools and libraries for using data in the INSDC Sequence Read Archives. Its detailed documentation can be found in https://trace.ncbi.nlm.nih.gov/Traces/sra/sra.cgi?view=toolkit_doc.

Link to section 'Versions' of 'sra-tools' Versions

2.11.0-pl5262

Link to section 'Module' of 'sra-tools' Module

You can load the modules by:

module load sra-tools

Link to section 'Configuring SRA-Toolkit' of 'sra-tools' Configuring SRA-Toolkit

Users can config SRA-Toolkit by the command vdb-config. For example, the below command set up the current working directory for downloading:

vdb-config --prefetch-to-cwd

Link to section 'Example job' of 'sra-tools' Example job

To run SRA-Toolkit on our cluster:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=SRA-Toolkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml sra-tools

vdb-config --prefetch-to-cwd # The data will be downloaded to the current working directory.  
prefetch SRR11941281
fastq-dump --split-3 SRR11941281/SRR11941281.sra

srst2

Link to section 'Introduction' of 'srst2' Introduction

Srst2 is designed to take Illumina sequence data, a MLST database and/or a database of gene sequences (e.g. resistance genes, virulence genes, etc) and report the presence of STs and/or reference genes. For more information, please check: Docker hub: https://hub.docker.com/r/staphb/srst2
Home page: https://github.com/katholt/srst2

Link to section 'Versions' of 'srst2' Versions

0.2.0

Link to section 'Commands' of 'srst2' Commands

getmlst.py
srst2
slurm_srst2.py

Link to section 'Module' of 'srst2' Module

You can load the modules by:

module load biocontainers
module load srst2

Link to section 'Example job' of 'srst2' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run srst2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=srst2
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers srst2

stacks

Link to section 'Introduction' of 'stacks' Introduction

Stacks is a software pipeline for building loci from RAD-seq.

For more information, please check its website: https://biocontainers.pro/tools/stacks.

Link to section 'Versions' of 'stacks' Versions

2.60

Link to section 'Module' of 'stacks' Module

You can load the modules by:

module load biocontainers
module load stacks

Link to section 'Example job' of 'stacks' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Stacks on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=stacks
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers stacks

denovo_map.pl -T 8 -M 4 -o ./stacks/  \
    --samples ./samples --popmap ./popmaps/popmap

star

STAR: ultrafast universal RNA-seq aligner.

Detailed usage can be found here: https://github.com/alexdobin/STAR

Link to section 'Versions' of 'star' Versions

2.7.10a
2.7.10b
2.7.9a

Link to section 'Commands' of 'star' Commands

STAR
STARlong

Link to section 'Module' of 'star' Module

You can load the modules by:

module load biocontainers
module load star/2.7.10a

Link to section 'Example job' of 'star' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run STAR on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=star
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers star/2.7.10a


STAR  --runThreadN 24  --runMode genomeGenerate  --genomeDir ref_genome  --genomeFastaFiles ref_genome.fasta

STAR --runThreadN 24 --genomeDir ref_genome --readFilesIn seq_1.fastq seq_2.fastq  --outSAMtype BAM SortedByCoordinate --outWigType wiggle read2

staramr

Link to section 'Introduction' of 'staramr' Introduction

staramr scans bacterial genome contigs against the ResFinder, PointFinder, and PlasmidFinder databases (used by the ResFinder webservice and other webservices offered by the Center for Genomic Epidemiology) and compiles a summary report of detected antimicrobial resistance genes.

Docker hub: https://hub.docker.com/r/staphb/staramr
Home page: https://github.com/phac-nml/staramr

Link to section 'Versions' of 'staramr' Versions

0.7.1

Link to section 'Commands' of 'staramr' Commands

staramr

Link to section 'Module' of 'staramr' Module

You can load the modules by:

module load biocontainers
module load staramr

Link to section 'Example job' of 'staramr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run staramr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=staramr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers staramr

staramr db info
staramr search \ 
    --pointfinder-organism salmonella \
    -o out *.fasta

starfusion

Link to section 'Introduction' of 'starfusion' Introduction

STAR-Fusion is a component of the Trinity Cancer Transcriptome Analysis Toolkit (CTAT).

Docker hub: https://hub.docker.com/r/trinityctat/starfusion and its home page on Github.

Link to section 'Versions' of 'starfusion' Versions

1.11b

Link to section 'Commands' of 'starfusion' Commands

STAR-Fusion

Link to section 'Module' of 'starfusion' Module

You can load the modules by:

module load biocontainers
module load starfusion

Link to section 'Example job' of 'starfusion' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run STAR-Fusion on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=starfusion
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers starfusion

STAR-Fusion --CPU 24 --left_fq ../star/SRR12095148_1.fastq --right_fq  ../star/SRR12095148_2.fastq\
     --genome_lib_dir  GRCh38_gencode_v33_CTAT_lib_Apr062020.plug-n-play/ctat_genome_lib_build_dir \
     --FusionInspector validate \
     --denovo_reconstruct \
     --examine_coding_effect \
     --output_dir STAR-Fusion-output

stream

Link to section 'Introduction' of 'stream' Introduction

STREAM (Single-cell Trajectories Reconstruction, Exploration And Mapping) is an interactive pipeline capable of disentangling and visualizing complex branching trajectories from both single-cell transcriptomic and epigenomic data.

Docker hub: https://hub.docker.com/r/pinellolab/stream and its home page on Github.

Link to section 'Versions' of 'stream' Versions

Link to section 'Commands' of 'stream' Commands

python
python3

Link to section 'Module' of 'stream' Module

You can load the modules by:

module load biocontainers
module load stream

Link to section 'Example job' of 'stream' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run STREAM on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=stream
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers stream

stringdecomposer

Link to section 'Introduction' of 'stringdecomposer' Introduction

Stringdecomposer is a tool for decomposition centromeric assemblies and long reads into monomers.

BioContainers: https://biocontainers.pro/tools/stringdecomposer
Home page: https://github.com/ablab/stringdecomposer

Link to section 'Versions' of 'stringdecomposer' Versions

1.1.2

Link to section 'Commands' of 'stringdecomposer' Commands

stringdecomposer

Link to section 'Module' of 'stringdecomposer' Module

You can load the modules by:

module load biocontainers
module load stringdecomposer

Link to section 'Example job' of 'stringdecomposer' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run stringdecomposer on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=stringdecomposer
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers stringdecomposer

stringtie

StringTie: efficient transcript assembly and quantitation of RNA-Seq data.

Stringtie employs efficient algorithms for transcript structure recovery and abundance estimation from bulk RNA-Seq reads aligned to a reference genome. It takes as input spliced alignments in coordinate-sorted SAM/BAM/CRAM format and produces a GTF output which consists of assembled transcript structures and their estimated expression levels (FPKM/TPM and base coverage values).

Detailed usage can be found here: https://github.com/gpertea/stringtie

Link to section 'Versions' of 'stringtie' Versions

2.1.7
2.2.1

Link to section 'Commands' of 'stringtie' Commands

stringtie

Link to section 'Module' of 'stringtie' Module

You can load the modules by:

module load biocontainers
module load stringtie

Link to section 'Example job' of 'stringtie' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run stringtie on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=stringtie
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers stringtie

stringtie -o SRR11614710.gtf -G Homo_sapiens.GRCh38.105.gtf SRR11614710Aligned.sortedByCoord.out.bam

strique

Link to section 'Introduction' of 'strique' Introduction

STRique is a python package to analyze repeat expansion and methylation states of short tandem repeats (STR) in Oxford Nanopore Technology (ONT) long read sequencing data.

Docker hub: https://hub.docker.com/r/giesselmann/strique
Home page: https://github.com/giesselmann/STRique

Link to section 'Versions' of 'strique' Versions

0.4.2

Link to section 'Commands' of 'strique' Commands

STRique.py
STRique_test.py
fast5Masker.py

Link to section 'Module' of 'strique' Module

You can load the modules by:

module load biocontainers
module load strique

Link to section 'Example job' of 'strique' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run strique on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=strique
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers strique

STRique_test.py
STRique.py index data/ > data/reads.fofn
cat data/c9orf72.sam |  STRique.py count ./data/reads.fofn ./models/r9_4_450bps.model ./configs/repeat_config.tsv --config ./configs/STRique.json

structure

Link to section 'Introduction' of 'structure' Introduction

Structure is a software package for using multi-locus genotype data to investigate population structure.

Home page: https://web.stanford.edu/group/pritchardlab/structure.html

Link to section 'Versions' of 'structure' Versions

2.3.4

Link to section 'Commands' of 'structure' Commands

structure

Link to section 'Module' of 'structure' Module

You can load the modules by:

module load biocontainers
module load structure

Link to section 'Example job' of 'structure' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run structure on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=structure
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers structure

subread

Link to section 'Introduction' of 'subread' Introduction

Subread carries out high-performance read alignment, quantification and mutation discovery. It is a general-purpose read aligner which can be used to map both genomic DNA-seq reads and DNA-seq reads. It uses a new mapping paradigm called seed-and-vote to achieve fast, accurate and scalable read mapping. Subread automatically determines if a read should be globally or locally aligned, therefore particularly powerful in mapping RNA-seq reads. It supports INDEL detection and can map reads with both fixed and variable lengths.

For more information, please check its website: https://biocontainers.pro/tools/subread and its home page: http://subread.sourceforge.net.

Link to section 'Versions' of 'subread' Versions

1.6.4
2.0.1

Link to section 'Module' of 'subread' Module

You can load the modules by:

module load biocontainers
module load subread

Link to section 'Example job' of 'subread' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Subread on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=subread
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers subread

featureCounts -s 2 -p -Q 10 -T 4 -a genome.gtf -o featurecounts.txt mapped.bam

survivor

Link to section 'Introduction' of 'survivor' Introduction

SURVIVOR is a tool set for simulating/evaluating SVs, merging and comparing SVs within and among samples, and includes various methods to reformat or summarize SVs.

BioContainers: https://biocontainers.pro/tools/survivor
Home page: https://github.com/fritzsedlazeck/SURVIVOR

Link to section 'Versions' of 'survivor' Versions

1.0.7

Link to section 'Commands' of 'survivor' Commands

SURVIVOR

Link to section 'Module' of 'survivor' Module

You can load the modules by:

module load biocontainers
module load survivor

Link to section 'Example job' of 'survivor' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run survivor on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=survivor
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers survivor

SURVIVOR simSV parameter_file
SURVIVOR simSV ref.fa parameter_file 0.1 0 simulated
SURVIVOR eval caller.vcf simulated.bed 10 eval_res

svaba

Link to section 'Introduction' of 'svaba' Introduction

SvABA is a method for detecting structural variants in sequencing data using genome-wide local assembly.

BioContainers: https://biocontainers.pro/tools/svaba
Home page: https://github.com/walaj/svaba

Link to section 'Versions' of 'svaba' Versions

1.1.0

Link to section 'Commands' of 'svaba' Commands

svaba

Link to section 'Module' of 'svaba' Module

You can load the modules by:

module load biocontainers
module load svaba

Link to section 'Example job' of 'svaba' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run svaba on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=svaba
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers svaba

DBSNP=dbsnp_indel.vcf
TUM_BAM=G15512.HCC1954.1.COST16011_region.bam
NORM_BAM=HCC1954.NORMAL.30x.compare.COST16011_region.bam
CORES=8 ## set any number of cores
REF=Homo_sapiens_assembly19.COST16011_region.fa
svaba run -t $TUM_BAM -n $NORM_BAM \
    -p $CORES -D $DBSNP \
    -a somatic_run -G $REF

svtools

Link to section 'Introduction' of 'svtools' Introduction

Svtools is a suite of utilities designed to help bioinformaticians construct and explore cohort-level structural variation calls.

Docker hub: https://hub.docker.com/r/halllab/svtools
Home page: https://github.com/hall-lab/svtools

Link to section 'Versions' of 'svtools' Versions

0.5.1

Link to section 'Commands' of 'svtools' Commands

svtools

Link to section 'Module' of 'svtools' Module

You can load the modules by:

module load biocontainers
module load svtools

Link to section 'Example job' of 'svtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run svtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=svtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers svtools

svtyper

Link to section 'Introduction' of 'svtyper' Introduction

SVTyper performs breakpoint genotyping of structural variants (SVs) using whole genome sequencing data. svtyper is the original implementation of the genotyping algorithm, and works with multiple samples. svtyper-sso is an alternative implementation of svtyper that is optimized for genotyping a single sample. svtyper-sso is a parallelized implementation of svtyper that takes advantage of multiple CPU cores via the multiprocessing module. svtyper-sso can offer a 2x or more speedup (depending on how many CPU cores used) in genotyping a single sample. NOTE: svtyper-sso is not yet stable. There are minor logging differences between the two and svtyper-sso may exit with an error prematurely when processing CRAM files.

BioContainers: https://biocontainers.pro/tools/svtyper
Home page: https://github.com/hall-lab/svtyper

Link to section 'Versions' of 'svtyper' Versions

0.7.1

Link to section 'Commands' of 'svtyper' Commands

svtyper
svtyper-sso
python
python2

Link to section 'Module' of 'svtyper' Module

You can load the modules by:

module load biocontainers
module load svtyper

Link to section 'Example job' of 'svtyper' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run svtyper on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=svtyper
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers svtyper

svtyper \
    -i data/example.vcf \
    -B data/NA12878.target_loci.sorted.bam \
    -l data/NA12878.bam.json \
    > out.vcf

swat

Link to section 'Introduction' of 'swat' Introduction

swat is a program for searching one or more DNA or protein query sequences, or a query profile, against a sequence database, using an efficient implementation of the Smith-Waterman or Needleman-Wunsch algorithms with linear (affine) gap penalties.

For more information, please check its home page: http://www.phrap.org/phredphrapconsed.html#block_phrap.

Link to section 'Versions' of 'swat' Versions

1.090518

Link to section 'Commands' of 'swat' Commands

swat

Link to section 'Module' of 'swat' Module

You can load the modules by:

module load biocontainers
module load swat

Link to section 'Example job' of 'swat' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run swat on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=swat
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers swat

syri

Link to section 'Introduction' of 'syri' Introduction

Syri compares alignments between two chromosome-level assemblies and identifies synteny and structural rearrangements.

Home page: https://github.com/schneebergerlab/syri

Link to section 'Versions' of 'syri' Versions

Link to section 'Commands' of 'syri' Commands

syri

Link to section 'Module' of 'syri' Module

You can load the modules by:

module load biocontainers
module load syri

Link to section 'Example job' of 'syri' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run syri on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=syri
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers syri

syri -c out.sam -r refgenome -q qrygenome -k -F S

t-coffee

Link to section 'Introduction' of 't-coffee' Introduction

T-coffee is a multiple sequence alignment software using a progressive approach.

For more information, please check its website: https://biocontainers.pro/tools/t-coffee and its home page on Github.

Link to section 'Versions' of 't-coffee' Versions

13.45.0.4846264

Link to section 'Commands' of 't-coffee' Commands

t_coffee

Link to section 'Module' of 't-coffee' Module

You can load the modules by:

module load biocontainers
module load t-coffee

Link to section 'Example job' of 't-coffee' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run T-coffee on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=t-coffee
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers t-coffee

t_coffee  OG0002077.fa -mode  expresso

talon

Link to section 'Introduction' of 'talon' Introduction

Talon is a Python package for identifying and quantifying known and novel genes/isoforms in long-read transcriptome data sets.

For more information, please check its website: https://biocontainers.pro/tools/talon and its home page on Github.

Link to section 'Versions' of 'talon' Versions

Link to section 'Module' of 'talon' Module

You can load the modules by:

module load biocontainers
module load talon

Link to section 'Example job' of 'talon' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Talon on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=talon
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers talon

targetp

Link to section 'Introduction' of 'targetp' Introduction

TargetP-2.0 tool predicts the presence of N-terminal presequences: signal peptide (SP), mitochondrial transit peptide (mTP), chloroplast transit peptide (cTP) or thylakoid luminal transit peptide (luTP). For the sequences predicted to contain an N-terminal presequence a potential cleavage site is also predicted.

Home page: https://services.healthtech.dtu.dk/service.php?TargetP-2.0

Link to section 'Versions' of 'targetp' Versions

Link to section 'Commands' of 'targetp' Commands

targetp

Link to section 'Module' of 'targetp' Module

You can load the modules by:

module load biocontainers
module load targetp

Link to section 'Example job' of 'targetp' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run targetp on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=targetp
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers targetp

tassel

Link to section 'Introduction' of 'tassel' Introduction

TASSEL is a software package used to evaluate traits associations, evolutionary patterns, and linkage disequilibrium.

Home page: https://www.maizegenetics.net/tassel

Link to section 'Versions' of 'tassel' Versions

Link to section 'Commands' of 'tassel' Commands

run_pipeline.pl
start_tassel.pl
Tassel5

Link to section 'Module' of 'tassel' Module

You can load the modules by:

module load biocontainers
module load tassel

Link to section 'Example job' of 'tassel' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run tassel on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=tassel
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tassel

taxonkit

Link to section 'Introduction' of 'taxonkit' Introduction

Taxonkit is a practical and efficient NCBI taxonomy toolkit.

For more information, please check its website: https://biocontainers.pro/tools/taxonkit and its home page on Github.

Link to section 'Versions' of 'taxonkit' Versions

0.9.0

Link to section 'Commands' of 'taxonkit' Commands

taxonkit

Link to section 'Module' of 'taxonkit' Module

You can load the modules by:

module load biocontainers
module load taxonkit

Link to section 'Example job' of 'taxonkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Taxonkit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=taxonkit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers taxonkit

taxonkit list --show-rank --show-name --indent "    " --ids 9605,239934

tetranscripts

Link to section 'Introduction' of 'tetranscripts' Introduction

Tetranscripts is a package for including transposable elements in differential enrichment analysis of sequencing datasets.

For more information, please check its website: https://biocontainers.pro/tools/tetranscripts and its home page on Github.

Link to section 'Versions' of 'tetranscripts' Versions

2.2.1

Link to section 'Commands' of 'tetranscripts' Commands

TEtranscripts
TEcount

Link to section 'Module' of 'tetranscripts' Module

You can load the modules by:

module load biocontainers
module load tetranscripts

Link to section 'Example job' of 'tetranscripts' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Tetranscripts on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=tetranscripts
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tetranscripts

TEtranscripts --format BAM --mode multi \
    -t treatment_sample1.bam treatment_sample2.bam treatment_sample3.bam \
    -c control_sample1.bam control_sample2.bam control_sample3.bam \
    --GTF genic-GTF-file \
    --GTF genic-GTF-file \  
    --project sample_nosort_test

tiara

Link to section 'Introduction' of 'tiara' Introduction

Tiara is a deep-learning-based approach for identification of eukaryotic sequences in the metagenomic data powered by PyTorch.

Docker hub: https://hub.docker.com/r/zhan4429/tiara and its home page on Github.

Link to section 'Versions' of 'tiara' Versions

1.0.2

Link to section 'Commands' of 'tiara' Commands

tiara

Link to section 'Module' of 'tiara' Module

You can load the modules by:

module load biocontainers
module load tiara

Link to section 'Example job' of 'tiara' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Tiara on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=tiara
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tiara

tiara -t 24 -i archaea_fr.fasta -o archaea_out.txt
tiara -t 24 -i bacteria_fr.fasta -o bacteria_out.txt
tiara -t 24 -i eukarya_fr.fasta -o eukarya_out.txt
tiara -t 24 -i mitochondria_fr.fasta -o mitochondria_out.txt
tiara -t 24  -i plast_fr.fasta -o plast_out.txt
tiara -t 24  -i total.fasta -o mix_out.txt  --tf all  -p 0.65 0.60 --probabilities

tigmint

Link to section 'Introduction' of 'tigmint' Introduction

Tigmint identifies and corrects misassemblies using linked (e.g. MGI's stLFR, 10x Genomics Chromium) or long (e.g. Oxford Nanopore Technologies long reads) DNA sequencing reads. The reads are first aligned to the assembly, and the extents of the large DNA molecules are inferred from the alignments of the reads. The physical coverage of the large molecules is more consistent and less prone to coverage dropouts than that of the short read sequencing data. The sequences are cut at positions that have insufficient spanning molecules. Tigmint outputs a BED file of these cut points, and a FASTA file of the cut sequences. For more information, please check: Home page: https://github.com/bcgsc/tigmint

Link to section 'Versions' of 'tigmint' Versions

1.2.6

Link to section 'Commands' of 'tigmint' Commands

tigmint
tigmint-arcs-tsv
tigmint-cut
tigmint-make
tigmint_estimate_dist.py
tigmint_molecule.py
tigmint_molecule_paf.py

Link to section 'Module' of 'tigmint' Module

You can load the modules by:

module load biocontainers
module load tigmint

Link to section 'Example job' of 'tigmint' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run tigmint on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=tigmint
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tigmint

tobias

Link to section 'Introduction' of 'tobias' Introduction

Tobias is a collection of command-line bioinformatics tools for performing footprinting analysis on ATAC-seq data.

For more information, please check its website: https://biocontainers.pro/tools/tobias and its home page on Github.

Link to section 'Versions' of 'tobias' Versions

0.13.3

Link to section 'Commands' of 'tobias' Commands

TOBIAS

Link to section 'Module' of 'tobias' Module

You can load the modules by:

module load biocontainers
module load tobias

Link to section 'Example job' of 'tobias' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Tobias on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=tobias
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tobias

TOBIAS DownloadData --bucket data-tobias-2020
mv data-tobias-2020/ test_data/

TOBIAS PlotAggregate --TFBS test_data/BATF_all.bed \
     --signals test_data/Bcell_corrected.bw test_data/Tcell_corrected.bw \
     --output BATFJUN_footprint_comparison_all.pdf \
     --share_y both --plot_boundaries --signal-on-x

TOBIAS BINDetect --motifs test_data/motifs.jaspar \
     --signals test_data/Bcell_footprints.bw test_data/Tcell_footprints.bw \
     --genome test_data/genome.fa.gz \
     --peaks test_data/merged_peaks_annotated.bed \
     --peak_header test_data/merged_peaks_annotated_header.txt \
     --outdir BINDetect_output --cond_names Bcell Tcell --cores 8

TOBIAS ATACorrect --bam test_data/Bcell.bam \
    --genome test_data/genome.fa.gz \
    --peaks test_data/merged_peaks.bed \
    --blacklist test_data/blacklist.bed \
    --outdir ATACorrect_test --cores 8

TOBIAS FootprintScores --signal test_data/Bcell_corrected.bw \
    --regions test_data/merged_peaks.bed \
    --output Bcell_footprints.bw --cores 8

tombo

Link to section 'Introduction' of 'tombo' Introduction

Tombo is a suite of tools primarily for the identification of modified nucleotides from nanopore sequencing data. Tombo also provides tools for the analysis and visualization of raw nanopore signal.

For more information, please check its website: https://biocontainers.pro/tools/ont-tombo and its home page on Github.

Link to section 'Versions' of 'tombo' Versions

1.5.1

Link to section 'Commands' of 'tombo' Commands

tombo

Link to section 'Module' of 'tombo' Module

You can load the modules by:

module load biocontainers
module load tombo

Link to section 'Example job' of 'tombo' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Tombo on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=tombo
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tombo

tombo resquiggle path/to/fast5s/ genome.fasta --processes 4 --num-most-common-errors 5
tombo detect_modifications alternative_model --fast5-basedirs path/to/fast5s/ \
    --statistics-file-basename native.e_coli_sample \
    --alternate-bases dam dcm --processes 4

# plot raw signal at most significant dcm locations
tombo plot most_significant --fast5-basedirs path/to/fast5s/ \
    --statistics-filename native.e_coli_sample.dcm.tombo.stats \
    --plot-standard-model --plot-alternate-model dcm \
    --pdf-filename sample.most_significant_dcm_sites.pdf

# produces wig file with estimated fraction of modified reads at each valid reference site
tombo text_output browser_files --statistics-filename native.e_coli_sample.dam.tombo.stats \
     --file-types dampened_fraction --browser-file-basename native.e_coli_sample.dam
# also produce successfully processed reads coverage file for reference
tombo text_output browser_files --fast5-basedirs path/to/fast5s/ \
    --file-types coverage --browser-file-basename native.e_coli_sample

tophat

Link to section 'Introduction' of 'tophat' Introduction

TopHat is a fast splice junction mapper for RNA-Seq reads. It aligns RNA-Seq reads to mammalian-sized genomes using the ultra high-throughput short read aligner Bowtie, and then analyzes the mapping results to identify splice junctions between exons.

For more information, please check its website: https://biocontainers.pro/tools/tophat and its home page: https://ccb.jhu.edu/software/tophat/index.shtml.

Link to section 'Versions' of 'tophat' Versions

2.1.1-py27

Link to section 'Commands' of 'tophat' Commands

tophat
tophat2

Link to section 'Module' of 'tophat' Module

You can load the modules by:

module load biocontainers
module load tophat

Link to section 'Example job' of 'tophat' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run TopHat on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=tophat
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers tophat

tophat -r 20 test_ref reads_1.fq reads_2.fq

tpmcalculator

TPMCalculator quantifies mRNA abundance directly from the alignments by parsing BAM files.

Detailed usage can be found here: https://github.com/ncbi/TPMCalculator

Link to section 'Versions' of 'tpmcalculator' Versions

0.0.3
0.0.4

Link to section 'Commands' of 'tpmcalculator' Commands

TPMCalculator

Link to section 'Module' of 'tpmcalculator' Module

You can load the modules by:

module load biocontainers
module load tpmcalculator

Link to section 'Example job' of 'tpmcalculator' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run tpmcalculator on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=tpmcalculator
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers transdecoder

TPMCalculator -g Homo_sapiens.GRCh38.105.chr.gtf -b SRR12095148Aligned.sortedByCoord.out.bam

transabyss

Link to section 'Introduction' of 'transabyss' Introduction

Transabyss is a tool for De novo assembly of RNAseq data using ABySS.

For more information, please check its home page on Github.

Link to section 'Versions' of 'transabyss' Versions

2.0.1

Link to section 'Commands' of 'transabyss' Commands

transabyss
transabyss-merge

Link to section 'Module' of 'transabyss' Module

You can load the modules by:

module load biocontainers
module load transabyss

Link to section 'Example job' of 'transabyss' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Transabyss on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=transabyss
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers transabyss

transabyss --name  SRR12095148 \
    --pe SRR12095148_1.fastq SRR12095148_2.fastq \
    --outdir  SRR12095148_assembly  --threads 12

transdecoder

TransDecoder identifies candidate coding regions within transcript sequences, such as those generated by de novo RNA-Seq transcript assembly using Trinity, or constructed based on RNA-Seq alignments to the genome using Tophat and Cufflinks.

TransDecoder identifies likely coding sequences based on the following criteria:
a minimum length open reading frame (ORF) is found in a transcript sequence
a log-likelihood score similar to what is computed by the GeneID software is > 0.
the above coding score is greatest when the ORF is scored in the 1st reading frame as compared to scores in the other 2 forward reading frames.
if a candidate ORF is found fully encapsulated by the coordinates of another candidate ORF, the longer one is reported. However, a single transcript can report multiple ORFs (allowing for operons, chimeras, etc).
a PSSM is built/trained/used to refine the start codon prediction.
optional the putative peptide has a match to a Pfam domain above the noise cutoff score.

Detailed usage can be found here: https://github.com/TransDecoder/TransDecoder/wiki#running-transdecoder

Link to section 'Versions' of 'transdecoder' Versions

5.5.0

Link to section 'Module' of 'transdecoder' Module

You can load the modules by:

module load biocontainers
module load transdecoder

Link to section 'Example job' of 'transdecoder' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run transdecoder on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 20:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=transdecoder
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers transdecoder

gtf_genome_to_cdna_fasta.pl transcripts.gtf test.genome.fasta > transcripts.fasta 
gtf_to_alignment_gff3.pl transcripts.gtf > transcripts.gff3
TransDecoder.LongOrfs -t transcripts.fasta
TransDecoder.Predict -t transcripts.fasta

transrate

Link to section 'Introduction' of 'transrate' Introduction

Transrate is software for de-novo transcriptome assembly quality analysis.

Docker hub: https://hub.docker.com/r/arnaudmeng/transrate
Home page: http://hibberdlab.com/transrate/

Link to section 'Versions' of 'transrate' Versions

1.0.3

Link to section 'Commands' of 'transrate' Commands

transrate

Link to section 'Module' of 'transrate' Module

You can load the modules by:

module load biocontainers
module load transrate

Link to section 'Example job' of 'transrate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run transrate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=transrate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers transrate

transrate --assembly mm10/Mus_musculus.GRCm38.cds.all.fa \
    --left seq_1.fq.gz \
    --right seq_2.fq.gz \
    --threads 12

transvar

Link to section 'Introduction' of 'transvar' Introduction

Transvar is a multi-way annotator for genetic elements and genetic variations.

Docker hub: https://hub.docker.com/r/zhouwanding/transvar and its home page: https://bioinformatics.mdanderson.org/public-software/transvar/.

Link to section 'Versions' of 'transvar' Versions

2.5.9

Link to section 'Commands' of 'transvar' Commands

transvar

Link to section 'Module' of 'transvar' Module

You can load the modules by:

module load biocontainers
module load transvar

Link to section 'Example job' of 'transvar' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Transvar on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=transvar
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers transvar

# set up databases
transvar config --download_anno --refversion hg19

# in case you don't have a reference
transvar config --download_ref --refversion hg19

transvar panno -i 'PIK3CA:p.E545K' --ucsc --ccds

trax

Link to section 'Introduction' of 'trax' Introduction

tRAX (tRNA Analysis of eXpression) is a software package built for in-depth analyses of tRNA-derived small RNAs (tDRs), mature tRNAs, and inference of RNA modifications from high-throughput small RNA sequencing data.

Docker hub: https://hub.docker.com/r/ucsclowelab/trax and its home page on Github.

Link to section 'Versions' of 'trax' Versions

1.0.0

Link to section 'Commands' of 'trax' Commands

TestRun.bash
quickdb.bash
maketrnadb.py
trimadapters.py
processamples.py

Link to section 'Module' of 'trax' Module

You can load the modules by:

module load biocontainers
module load trax

Link to section 'Example job' of 'trax' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run tRAX on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trax
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trax

treetime

Link to section 'Introduction' of 'treetime' Introduction

Treetime is a tool for maximum likelihood dating and ancestral sequence inference.

For more information, please check its website: https://biocontainers.pro/tools/treetime and its home page on Github.

Link to section 'Versions' of 'treetime' Versions

0.8.6
0.9.4

Link to section 'Commands' of 'treetime' Commands

treetime

Link to section 'Module' of 'treetime' Module

You can load the modules by:

module load biocontainers
module load treetime

Link to section 'Example job' of 'treetime' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Treetime on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=treetime
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers treetime

treetime ancestral --aln input.fasta --tree input.nwk

trim-galore

Link to section 'Introduction' of 'trim-galore' Introduction

Trim-galore is a wrapper tool that automates quality and adapter trimming to FastQ files.

For more information, please check its website: https://biocontainers.pro/tools/trim-galore and its home page: https://www.bioinformatics.babraham.ac.uk/projects/trim_galore/.

Link to section 'Versions' of 'trim-galore' Versions

0.6.7

Link to section 'Commands' of 'trim-galore' Commands

trim_galore

Link to section 'Module' of 'trim-galore' Module

You can load the modules by:

module load biocontainers
module load trim-galore

Link to section 'Example job' of 'trim-galore' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trim-galore on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 4
#SBATCH --job-name=trim-galore
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trim-galore

trim_galore  --paired --fastqc --length 20 -o sample1_trimmed Sample1_1.fq Sample1_2.fq

trimal

Link to section 'Introduction' of 'trimal' Introduction

Trimal is a tool for the automated removal of spurious sequences or poorly aligned regions from a multiple sequence alignment.

For more information, please check its website: https://biocontainers.pro/tools/trimal and its home page: http://trimal.cgenomics.org.

Link to section 'Versions' of 'trimal' Versions

1.4.1

Link to section 'Commands' of 'trimal' Commands

trimal
readal
statal

Link to section 'Module' of 'trimal' Module

You can load the modules by:

module load biocontainers
module load trimal

Link to section 'Example job' of 'trimal' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trimal on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trimal
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trimal

trimal -in input.fasta -out output1 -htmlout output1.html -gt 1

trimmomatic

Link to section 'Introduction' of 'trimmomatic' Introduction

Trimmomatic is a flexible read trimming tool for Illumina NGS data.

For more information, please check its website: https://biocontainers.pro/tools/trimmomatic.

Link to section 'Versions' of 'trimmomatic' Versions

0.39

Link to section 'Commands' of 'trimmomatic' Commands

trimmomatic

Link to section 'Module' of 'trimmomatic' Module

You can load the modules by:

module load biocontainers
module load trimmomatic

Link to section 'Example job' of 'trimmomatic' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trimmomatic on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 8
#SBATCH --job-name=trimmomatic
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trimmomatic

trimmomatic PE -threads 8 \
    input_forward.fq.gz input_reverse.fq.gz \ 
    output_forward_paired.fq.gz output_forward_unpaired.fq.gz \
    output_reverse_paired.fq.gz output_reverse_unpaired.fq.gz \
    ILLUMINACLIP:TruSeq3-PE.fa:2:30:10:2:True LEADING:3 TRAILING:3 MINLEN:36

trinity

Link to section 'Introduction' of 'trinity' Introduction

Trinity assembles transcript sequences from Illumina RNA-Seq data.

For more information, please check its website: https://biocontainers.pro/tools/trinity and its home page on Github.

Link to section 'Versions' of 'trinity' Versions

2.12.0
2.13.2
2.14.0
2.15.0

Link to section 'Module' of 'trinity' Module

You can load the modules by:

module load biocontainers
module load trinity

Link to section 'Example job' of 'trinity' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trinity on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 6
#SBATCH --job-name=trinity
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trinity

Trinity --seqType fq --left reads_1.fq --right reads_2.fq \
    --CPU 6 --max_memory 20G

trinotate

Link to section 'Introduction' of 'trinotate' Introduction

Trinotate is a comprehensive annotation suite designed for automatic functional annotation of transcriptomes, particularly de novo assembled transcriptomes, from model or non-model organisms.

For more information, please check its website: https://biocontainers.pro/tools/trinotate.

Link to section 'Versions' of 'trinotate' Versions

3.2.2

Link to section 'Module' of 'trinotate' Module

You can load the modules by:

module load biocontainers
module load trinotate

Link to section 'Example job' of 'trinotate' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trinotate on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trinotate
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trinotate

sqlite_db="myTrinotate.sqlite"

Trinotate ${sqlite_db} init \
    --gene_trans_map data/Trinity.fasta.gene_to_trans_map \
    --transcript_fasta data/Trinity.fasta \
     --transdecoder_pep \
    data/Trinity.fasta.transdecoder.pep

Trinotate ${sqlite_db} LOAD_swissprot_blastp data/swissprot.blastp.outfmt6

Trinotate ${sqlite_db} LOAD_pfam data/TrinotatePFAM.out

trnascan-se

Link to section 'Introduction' of 'trnascan-se' Introduction

Trnascan-se is a convenient, ready-for-use means to identify tRNA genes in one or more query sequences.

For more information, please check its website: https://biocontainers.pro/tools/trnascan-se and its home page: http://lowelab.ucsc.edu/tRNAscan-SE/.

Link to section 'Versions' of 'trnascan-se' Versions

2.0.9

Link to section 'Commands' of 'trnascan-se' Commands

tRNAscan-SE

Link to section 'Module' of 'trnascan-se' Module

You can load the modules by:

module load biocontainers
module load trnascan-se

Link to section 'Example job' of 'trnascan-se' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Trnascan-se on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=trnascan-se
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trnascan-se

tRNAscan-SE --thread 12 -o tRNA.out \
    -f rRNA.ss -m tRNA.stats genome.fasta

trtools

Link to section 'Introduction' of 'trtools' Introduction

TRTools includes a variety of utilities for filtering, quality control and analysis of tandem repeats downstream of genotyping them from next-generation sequencing.

BioContainers: https://biocontainers.pro/tools/trtools
Home page: https://github.com/gymreklab/TRTools

Link to section 'Versions' of 'trtools' Versions

5.0.1

Link to section 'Commands' of 'trtools' Commands

associaTR
compareSTR
dumpSTR
mergeSTR
qcSTR
statSTR

Link to section 'Module' of 'trtools' Module

You can load the modules by:

module load biocontainers
module load trtools

Link to section 'Example job' of 'trtools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

We noticed that xalt module can cause the failure of certain commands including statSTR. Please unload all loaded modules by module --force purge before loading required modules.

To run trtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trtools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trtools htslib bcftools 

mergeSTR --vcfs ceu_ex.vcf.gz,yri_ex.vcf.gz --out merged
bgzip merged.vcf
tabix -p vcf merged.vcf.gz
 
# Get the CEU and YRI sample lists
bcftools query -l yri_ex.vcf.gz > yri_samples.txt
bcftools query -l ceu_ex.vcf.gz > ceu_samples.txt

# Run statSTR on region chr21:35348646-35348646 (hg38)
statSTR \
    --vcf merged.vcf.gz \
    --samples yri_samples.txt,ceu_samples.txt \
    --sample-prefixes YRI,CEU \
    --out stdout \
    --mean --het --acount \
    --use-length \
    --region chr21:34351482-34363028

trust4

Link to section 'Introduction' of 'trust4' Introduction

Tcr Receptor Utilities for Solid Tissue (TRUST) is a computational tool to analyze TCR and BCR sequences using unselected RNA sequencing data, profiled from solid tissues, including tumors.

BioContainers: https://biocontainers.pro/tools/trust4
Home page: https://github.com/liulab-dfci/TRUST4

Link to section 'Versions' of 'trust4' Versions

1.0.7

Link to section 'Commands' of 'trust4' Commands

run-trust4
BuildDatabaseFa.pl
BuildImgtAnnot.pl
trust-airr.pl
trust-barcoderep.pl
trust-simplerep.pl
trust-smartseq.pl

Link to section 'Module' of 'trust4' Module

You can load the modules by:

module load biocontainers
module load trust4

Link to section 'Example job' of 'trust4' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run trust4 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trust4
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trust4

run-trust4 -b mapped.bam -f hg38_bcrtcr.fa --ref human_IMGT+C.fa

trycycler

Link to section 'Introduction' of 'trycycler' Introduction

Trycycler is a tool for generating consensus long-read assemblies for bacterial genomes. I.e. if you have multiple long-read assemblies for the same isolate, Trycycler can combine them into a single assembly that is better than any of your inputs.

Docker hub: https://hub.docker.com/r/staphb/trycycler
Home page: https://github.com/rrwick/Trycycler

Link to section 'Versions' of 'trycycler' Versions

0.5.0
0.5.3

Link to section 'Commands' of 'trycycler' Commands

trycycler

Link to section 'Module' of 'trycycler' Module

You can load the modules by:

module load biocontainers
module load trycycler

Link to section 'Example job' of 'trycycler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run trycycler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=trycycler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers trycycler

trycycler cluster --assemblies \
    test/test_cluster/assembly_*.fasta \
    --read test/test_cluster/reads.fastq \
    --out_dir trycycler_out

ucsc_genome_toolkit

UCSC Executables is a variety of executables that perform functions ranging from sequence analysis and format conversion, to basic number crunching and statistics, to complex database generation and manipulation.

These executables have been downloaded from http://hgdownload.soe.ucsc.edu/admin/exe/linux.x86_64.v369/ and made available on RCAC clusters.

Link to section 'Versions' of 'ucsc_genome_toolkit' Versions

Link to section 'Commands' of 'ucsc_genome_toolkit' Commands

addCols
ameme
autoDtd
autoSql
autoXml
ave
aveCols
axtChain
axtSort
axtSwap
axtToMaf
axtToPsl
bamToPsl
barChartMaxLimit
bedClip
bedCommonRegions
bedCoverage
bedExtendRanges
bedGeneParts
bedGraphPack
bedGraphToBigWig
bedIntersect
bedItemOverlapCount
bedJoinTabOffset
bedJoinTabOffset.py
bedMergeAdjacent
bedPartition
bedPileUps
bedRemoveOverlap
bedRestrictToPositions
bedSingleCover.pl
bedSort
bedToBigBed
bedToExons
bedToGenePred
bedToPsl
bedWeedOverlapping
bigBedInfo
bigBedNamedItems
bigBedSummary
bigBedToBed
bigGenePredToGenePred
bigHeat
bigMafToMaf
bigPslToPsl
bigWigAverageOverBed
bigWigCat
bigWigCluster
bigWigCorrelate
bigWigInfo
bigWigMerge
bigWigSummary
bigWigToBedGraph
bigWigToWig
binFromRange
blastToPsl
blastXmlToPsl
blat
calc
catDir
catUncomment
chainAntiRepeat
chainBridge
chainCleaner
chainFilter
chainMergeSort
chainNet
chainPreNet
chainScore
chainSort
chainSplit
chainStitchId
chainSwap
chainToAxt
chainToPsl
chainToPslBasic
checkAgpAndFa
checkCoverageGaps
checkHgFindSpec
checkTableCoords
chopFaLines
chromGraphFromBin
chromGraphToBin
chromToUcsc
clusterGenes
clusterMatrixToBarChartBed
colTransform
countChars
cpg_lh
crTreeIndexBed
crTreeSearchBed
dbSnoop
dbTrash
endsInLf
estOrient
expMatrixToBarchartBed
faAlign
faCmp
faCount
faFilter
faFilterN
faFrag
faNoise
faOneRecord
faPolyASizes
faRandomize
faRc
faSize
faSomeRecords
faSplit
faToFastq
faToTab
faToTwoBit
faToVcf
faTrans
fastqStatsAndSubsample
fastqToFa
featureBits
fetchChromSizes
findMotif
fixStepToBedGraph.pl
gapToLift
genePredCheck
genePredFilter
genePredHisto
genePredSingleCover
genePredToBed
genePredToBigGenePred
genePredToFakePsl
genePredToGtf
genePredToMafFrames
genePredToProt
gensub2
getRna
getRnaPred
gff3ToGenePred
gff3ToPsl
gmtime
gtfToGenePred
headRest
hgBbiDbLink
hgFakeAgp
hgFindSpec
hgGcPercent
hgGoldGapGl
hgLoadBed
hgLoadChain
hgLoadGap
hgLoadMaf
hgLoadMafSummary
hgLoadNet
hgLoadOut
hgLoadOutJoined
hgLoadSqlTab
hgLoadWiggle
hgSpeciesRna
hgTrackDb
hgWiggle
hgsql
hgsqldump
hgvsToVcf
hicInfo
htmlCheck
hubCheck
hubClone
hubPublicCheck
ixIxx
lastz-1.04.00
lastz_D-1.04.00
lavToAxt
lavToPsl
ldHgGene
liftOver
liftOverMerge
liftUp
linesToRa
localtime
mafAddIRows
mafAddQRows
mafCoverage
mafFetch
mafFilter
mafFrag
mafFrags
mafGene
mafMeFirst
mafNoAlign
mafOrder
mafRanges
mafSpeciesList
mafSpeciesSubset
mafSplit
mafSplitPos
mafToAxt
mafToBigMaf
mafToPsl
mafToSnpBed
mafsInRegion
makeTableList
maskOutFa
matrixClusterColumns
matrixMarketToTsv
matrixNormalize
mktime
mrnaToGene
netChainSubset
netClass
netFilter
netSplit
netSyntenic
netToAxt
netToBed
newProg
newPythonProg
nibFrag
nibSize
oligoMatch
overlapSelect
para
paraFetch
paraHub
paraHubStop
paraNode
paraNodeStart
paraNodeStatus
paraNodeStop
paraSync
paraTestJob
parasol
positionalTblCheck
pslCDnaFilter
pslCat
pslCheck
pslDropOverlap
pslFilter
pslHisto
pslLiftSubrangeBlat
pslMap
pslMapPostChain
pslMrnaCover
pslPairs
pslPartition
pslPosTarget
pslPretty
pslRc
pslRecalcMatch
pslRemoveFrameShifts
pslReps
pslScore
pslSelect
pslSomeRecords
pslSort
pslSortAcc
pslStats
pslSwap
pslToBed
pslToBigPsl
pslToChain
pslToPslx
pslxToFa
qaToQac
qacAgpLift
qacToQa
qacToWig
raSqlQuery
raToLines
raToTab
randomLines
rmFaDups
rowsToCols
sizeof
spacedToTab
splitFile
splitFileByColumn
sqlToXml
strexCalc
stringify
subChar
subColumn
tabQuery
tailLines
tdbQuery
tdbRename
tdbSort
textHistogram
tickToDate
toLower
toUpper
trackDbIndexBb
transMapPslToGenePred
trfBig
twoBitDup
twoBitInfo
twoBitMask
twoBitToFa
ucscApiClient
udr
vai.pl
validateFiles
validateManifest
varStepToBedGraph.pl
webSync
wigCorrelate
wigEncode
wigToBigWig
wordLine
xmlCat
xmlToSql

Link to section 'Module' of 'ucsc_genome_toolkit' Module

You can load the modules by:

module load biocontainers
module load ucsc_genome_toolkit/369

Link to section 'Example job' of 'ucsc_genome_toolkit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run UCSC executables on our our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=UCSC
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers ucsc_genome_toolkit/369

blat genome.fasta input.fasta blat.out
fastqToFa input.fastq  output.fasta

unicycler

Link to section 'Introduction' of 'unicycler' Introduction

Unicycler is an assembly pipeline for bacterial genomes.

For more information, please check its website: https://biocontainers.pro/tools/unicycler and its home page on Github.

Link to section 'Versions' of 'unicycler' Versions

0.5.0

Link to section 'Commands' of 'unicycler' Commands

unicycler

Link to section 'Module' of 'unicycler' Module

You can load the modules by:

module load biocontainers
module load unicycler

Link to section 'Example job' of 'unicycler' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Unicycler on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 12
#SBATCH --job-name=unicycler
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers unicycler

unicycler -t 12 -1 SRR11234553_1.fastq  -2 SRR11234553_2.fastq -o shortout

unicycler -t 12  -l SRR3982487.fastq  -o longout

vadr

Link to section 'Introduction' of 'vadr' Introduction

VADR is a suite of tools for classifying and analyzing sequences homologous to a set of reference models of viral genomes or gene families. It has been mainly tested for analysis of Norovirus, Dengue, and SARS-CoV-2 virus sequences in preparation for submission to the GenBank database.

Docker hub: https://hub.docker.com/r/staphb/vadr
Home page: https://github.com/ncbi/vadr

Link to section 'Versions' of 'vadr' Versions

1.4.1
1.4.2
1.5

Link to section 'Commands' of 'vadr' Commands

parse_blast.pl
v-annotate.pl
v-build.pl
v-test.pl

Link to section 'Module' of 'vadr' Module

You can load the modules by:

module load biocontainers
module load vadr

Link to section 'Example job' of 'vadr' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vadr on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vadr
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vadr

v-annotate.pl noro.9.fa va-noro.9

usefulaf

Link to section 'Introduction' of 'usefulaf' Introduction

Usefulaf is an all-in-one Docker/Singularity image for single-cell processing with Alevin-fry(paper). It includes the all tools you need to turn your FASTQ files into a count matrix and then load it into your favorite analysis environment.

Docker hub: https://hub.docker.com/r/combinelab/usefulaf
Home page: https://github.com/COMBINE-lab/usefulaf

Link to section 'Versions' of 'usefulaf' Versions

0.9.2

Link to section 'Commands' of 'usefulaf' Commands

simpleaf
R
Rscript
python
python3

Link to section 'Module' of 'usefulaf' Module

You can load the modules by:

module load biocontainers
module load usefulaf

Link to section 'Example job' of 'usefulaf' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run usefulaf on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=usefulaf
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers usefulaf

vardict-java

Link to section 'Introduction' of 'vardict-java' Introduction

VarDictJava is a variant discovery program written in Java and Perl. It is a Java port of VarDict variant caller.

Docker hub: https://hub.docker.com/r/hydragenetics/vardict
Home page: https://github.com/AstraZeneca-NGS/VarDictJava

Link to section 'Versions' of 'vardict-java' Versions

1.8.3

Link to section 'Commands' of 'vardict-java' Commands

vardict-java
var2vcf_paired.pl
var2vcf_valid.pl
testsomatic.R
teststrandbias.R

Link to section 'Module' of 'vardict-java' Module

You can load the modules by:

module load biocontainers
module load vardict-java

Link to section 'Example job' of 'vardict-java' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vardict-java on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vardict-java
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vardict-java

AF_THR="0.01" # minimum allele frequency
vardict-java -G genome.fasta \
    -f $AF_THR -N genome \
    -b input.bam \
    -c 1 -S 2 -E 3 -g 4 output.bed \
     |  teststrandbias.R \
     |  var2vcf_valid.pl \
     -N genome -E -f $AF_THR \
     > vars.vcf

varlociraptor

Link to section 'Introduction' of 'varlociraptor' Introduction

Varlociraptor implements a novel, unified fully uncertainty-aware approach to genomic variant calling in arbitrary scenarios.

For more information, please check its website: https://biocontainers.pro/tools/varlociraptor and its home page on Github.

Link to section 'Versions' of 'varlociraptor' Versions

4.11.4

Link to section 'Commands' of 'varlociraptor' Commands

varlociraptor

Link to section 'Module' of 'varlociraptor' Module

You can load the modules by:

module load biocontainers
module load varlociraptor

Link to section 'Example job' of 'varlociraptor' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Varlociraptor on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=varlociraptor
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers varlociraptor

varlociraptor call variants tumor-normal --purity 0.75 --tumor

varscan

Link to section 'Introduction' of 'varscan' Introduction

Varscan is a tool used for variant detection in massively parallel sequencing data.

For more information, please check its home page: http://varscan.sourceforge.net/index.html.

Link to section 'Versions' of 'varscan' Versions

2.4.2
2.4.4

Link to section 'Commands' of 'varscan' Commands

VarScan.v2.4.4.jar

Link to section 'Module' of 'varscan' Module

You can load the modules by:

module load biocontainers
module load varscan

Link to section 'Example job' of 'varscan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Varscan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=varscan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers varscan

vartrix

Link to section 'Introduction' of 'vartrix' Introduction

Vartrix is a software tool for extracting single cell variant information from 10x Genomics single cell data.

For more information, please check its website: https://biocontainers.pro/tools/vartrix and its home page on Github.

Link to section 'Versions' of 'vartrix' Versions

1.1.22

Link to section 'Commands' of 'vartrix' Commands

vartrix

Link to section 'Module' of 'vartrix' Module

You can load the modules by:

module load biocontainers
module load vartrix

Link to section 'Example job' of 'vartrix' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Vartrix on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vartrix
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vartrix

vartrix -v test/test.vcf -b test/test.bam \ 
    -f test/test.fa -c test/barcodes.tsv \
    -o output.matrix

vatools

Link to section 'Introduction' of 'vatools' Introduction

VAtools is a python package that includes several tools to annotate VCF files with data from other tools.

Docker hub: https://hub.docker.com/r/griffithlab/vatools
Home page: https://vatools.readthedocs.io/en/latest/

Link to section 'Versions' of 'vatools' Versions

5.0.1

Link to section 'Commands' of 'vatools' Commands

ref-transcript-mismatch-reporter
transform-split-values
vcf-expression-annotator
vcf-genotype-annotator
vcf-info-annotator
vcf-readcount-annotator
vep-annotation-reporter

Link to section 'Module' of 'vatools' Module

You can load the modules by:

module load biocontainers
module load vatools

Link to section 'Example job' of 'vatools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vatools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vatools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vatools

vcf-readcount-annotator <input_vcf> <snv_bam_readcount_file> <DNA| RNA> \
            -s <sample_name> -t snv -o <snv_annotated_vcf>

vcf-kit

Link to section 'Introduction' of 'vcf-kit' Introduction

VCF-kit is a command-line based collection of utilities for performing analysis on Variant Call Format (VCF) files.

BioContainers: https://biocontainers.pro/tools/vcf-kit
Home page: https://github.com/AndersenLab/VCF-kit

Link to section 'Versions' of 'vcf-kit' Versions

0.2.6
0.2.9

Link to section 'Commands' of 'vcf-kit' Commands

Link to section 'Module' of 'vcf-kit' Module

You can load the modules by:

module load biocontainers
module load vcf-kit

Link to section 'Example job' of 'vcf-kit' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vcf-kit on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vcf-kit
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vcf-kit

vcf2maf

Link to section 'Introduction' of 'vcf2maf' Introduction

To convert a VCF into a MAF, each variant must be mapped to only one of all possible gene transcripts/isoforms that it might affect. This selection of a single effect per variant, is often subjective. So this project is an attempt to make the selection criteria smarter, reproducible, and more configurable. And the default criteria must lean towards best practices.

Home page: https://github.com/mskcc/vcf2maf

Link to section 'Versions' of 'vcf2maf' Versions

1.6.21

Link to section 'Commands' of 'vcf2maf' Commands

maf2maf.pl
maf2vcf.pl
vcf2maf.pl
vcf2vcf.pl

Link to section 'Module' of 'vcf2maf' Module

You can load the modules by:

module load biocontainers
module load vcf2maf

Link to section 'Example job' of 'vcf2maf' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

If users need to use vep, please add --vep-path /opt/conda/bin.

To run vcf2maf on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vcf2maf
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vcf2maf

vcf2maf.pl --vep-path /opt/conda/bin \
    --ref-fasta Homo_sapiens.GRCh37.dna.toplevel.fa.gz \
    --input-vcf tests/test.vcf --output-maf test.vep.maf

vcf2phylip

Link to section 'Introduction' of 'vcf2phylip' Introduction

vcf2phylip is a tool to convert SNPs in VCF format to PHYLIP, NEXUS, binary NEXUS, or FASTA alignments for phylogenetic analysis.

Home page: https://github.com/edgardomortiz/vcf2phylip

Link to section 'Versions' of 'vcf2phylip' Versions

Link to section 'Commands' of 'vcf2phylip' Commands

vcf2phylip.py

Link to section 'Module' of 'vcf2phylip' Module

You can load the modules by:

module load biocontainers
module load vcf2phylip

Link to section 'Example job' of 'vcf2phylip' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vcf2phylip on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vcf2phylip
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vcf2phylip

vcf2phylip --input myfile.vcf

vcf2tsvpy

Link to section 'Introduction' of 'vcf2tsvpy' Introduction

Vcf2tsvpy is a small Python program that converts genomic variant data encoded in VCF format into a tab-separated values (TSV) file.

BioContainers: https://biocontainers.pro/tools/vcf2tsvpy
Home page: https://github.com/sigven/vcf2tsvpy

Link to section 'Versions' of 'vcf2tsvpy' Versions

0.6.0

Link to section 'Commands' of 'vcf2tsvpy' Commands

vcf2tsvpy

Link to section 'Module' of 'vcf2tsvpy' Module

You can load the modules by:

module load biocontainers
module load vcf2tsvpy

Link to section 'Example job' of 'vcf2tsvpy' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vcf2tsvpy on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vcf2tsvpy
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vcf2tsvpy

vcftools

Link to section 'Introduction' of 'vcftools' Introduction

VCFtools is a program package designed for working with VCF files, such as those generated by the 1000 Genomes Project. The aim of VCFtools is to provide easily accessible methods for working with complex genetic variation data in the form of VCF files.

For more information, please check its website: https://biocontainers.pro/tools/vcftools and its home page on Github.

Link to section 'Versions' of 'vcftools' Versions

0.1.16

Link to section 'Commands' of 'vcftools' Commands

vcftools

Link to section 'Module' of 'vcftools' Module

You can load the modules by:

module load biocontainers
module load vartrix

Link to section 'Example job' of 'vcftools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run VCFtools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vcftools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vcftools

vcftools --vcf input_data.vcf --chr 1 \
    --from-bp 1000000 --to-bp 2000000

velocyto.py

Velocyto.py a library for the analysis of RNA velocity.

Detailed information about velocyto.py can be found here: https://github.com/velocyto-team/velocyto.py.

Link to section 'Versions' of 'velocyto.py' Versions

0.17.17

Link to section 'Commands' of 'velocyto.py' Commands

python
python3
velocyto

Link to section 'Module' of 'velocyto.py' Module

You can load the modules by:

module load biocontainers  
module load velocyto.py/0.17.17-py39

Link to section 'Interactive job' of 'velocyto.py' Interactive job

To run Velocyto.py interactively on our clusters:

(base) UserID@bell-fe00:~ $ sinteractive -N1 -n12 -t4:00:00 -A myallocation
salloc: Granted job allocation 12345869
salloc: Waiting for resource configuration
salloc: Nodes bell-a008 are ready for job
(base) UserID@bell-a008:~ $ module load biocontainers cellrank/1.5.1
(base) UserID@bell-a008:~ $ python
Python 3.9.10 |  packaged by conda-forge |  (main, Feb  1 2022, 21:24:11)
[GCC 9.4.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.  
>>> import velocyto as vcy
>>> vlm = vcy.VelocytoLoom("YourData.loom")
>>> vlm.normalize("S", size=True, log=True)
>>> vlm.S_norm  # contains log normalized

Link to section 'Batch job' of 'velocyto.py' Batch job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To submit a sbatch job on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 10:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=Velocyto
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers velocyto.py/0.17.17-py39

velocyto run10x cellranger_count_1kpbmcs_out refdata-gex-GRCh38-2020-A/genes/genes.gtf

velvet

Link to section 'Introduction' of 'velvet' Introduction

Velvet is a sequence assembler for very short reads.

For more information, please check its website: https://biocontainers.pro/tools/velvet.

Link to section 'Versions' of 'velvet' Versions

1.2.10

Link to section 'Commands' of 'velvet' Commands

velveth
velvetg

Link to section 'Module' of 'velvet' Module

You can load the modules by:

module load biocontainers
module load trimmomatic

Link to section 'Example job' of 'velvet' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Velvet on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=velvet
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers velvet

velveth output_directory 21 -fasta -short solexa1.fa solexa2.fa solexa3.fa -long capillary.fa
velvetg output_directory -cov_cutoff 4

veryfasttree

Link to section 'Introduction' of 'veryfasttree' Introduction

VeryFastTree is a highly-tuned implementation of the FastTree-2 tool that takes advantage of parallelization and vectorization strategies to speed up the inference of phylogenies for huge alignments. It is important to highlight that VeryFastTree keeps unchanged the phases, methods and heuristics used by FastTree-2 to estimate the phylogenetic tree. In this way, it produces trees with the same topological accuracy than FastTree-2. In addition, unlike the parallel version of FastTree-2, VeryFastTree is deterministic.

BioContainers: https://biocontainers.pro/tools/veryfasttree
Home page: https://github.com/citiususc/veryfasttree

Link to section 'Versions' of 'veryfasttree' Versions

3.2.1

Link to section 'Commands' of 'veryfasttree' Commands

VeryFastTree

Link to section 'Module' of 'veryfasttree' Module

You can load the modules by:

module load biocontainers
module load veryfasttree

Link to section 'Example job' of 'veryfasttree' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run veryfasttree on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=veryfasttree
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers veryfasttree

vg

Link to section 'Introduction' of 'vg' Introduction

Variation graphs (vg) provides tools for working with genome variation graphs.

Home page: https://github.com/vgteam/vg

Link to section 'Versions' of 'vg' Versions

1.40.0

Link to section 'Commands' of 'vg' Commands

Link to section 'Module' of 'vg' Module

You can load the modules by:

module load biocontainers
module load vg

Link to section 'Example job' of 'vg' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run vg on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vg
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vg

vg construct -r test/small/x.fa -v test/small/x.vcf.gz >x.vg

# GFA output
vg view x.vg >x.gfa

# dot output suitable for graphviz
vg view -d x.vg >x.dot

# And if you have a GAM file
cp small/x-s1337-n1.gam x.gam

# json version of binary alignments
vg view -a x.gam >x.json

vg align -s CTACTGACAGCAGAAGTTTGCTGTGAAGATTAAATTAGGTGATGCTTG x.vg

viennarna

Link to section 'Introduction' of 'viennarna' Introduction

Viennarna is a set of standalone programs and libraries used for prediction and analysis of RNA secondary structures.

For more information, please check its website: https://biocontainers.pro/tools/viennarna and its home page: https://www.tbi.univie.ac.at/RNA/.

Link to section 'Versions' of 'viennarna' Versions

2.5.0

Link to section 'Module' of 'viennarna' Module

You can load the modules by:

module load biocontainers
module load viennarna

Link to section 'Example job' of 'viennarna' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Viennarna on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=viennarna
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers viennarna

RNAfold < test.seq
RNAfold -p --MEA < test.seq

weblogo

Link to section 'Introduction' of 'weblogo' Introduction

Weblogo is a web based application designed to make the generation of sequence logos as easy and painless as possible.

For more information, please check its website: https://biocontainers.pro/tools/weblogo and its home page: http://weblogo.threeplusone.com.

Link to section 'Versions' of 'weblogo' Versions

3.7.8

Link to section 'Commands' of 'weblogo' Commands

weblogo

Link to section 'Module' of 'weblogo' Module

You can load the modules by:

module load biocontainers
module load weblogo

Link to section 'Example job' of 'weblogo' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Weblogo on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=weblogo
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers weblogo

weblogo --resolution 600 --format PNG \
     <seq.fasta >logo.png

vsearch

Link to section 'Introduction' of 'vsearch' Introduction

Vsearch is a versatile open source tool for metagenomics.

For more information, please check its website: https://biocontainers.pro/tools/vsearch and its home page on Github.

Link to section 'Versions' of 'vsearch' Versions

2.19.0
2.21.1
2.22.1

Link to section 'Commands' of 'vsearch' Commands

vsearch

Link to section 'Module' of 'vsearch' Module

You can load the modules by:

module load biocontainers
module load vsearch

Link to section 'Example job' of 'vsearch' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Vsearch on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=vsearch
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers vsearch

vsearch -sintax SRR8723605_merged.fasta -db rdp_16s_v16_sp.fa \
    -tabbedout SRR8723605_out.txt -strand both -sintax_cutoff 0.5

whatshap

Link to section 'Introduction' of 'whatshap' Introduction

Whatshap is a software for phasing genomic variants using DNA sequencing reads, also called read-based phasing or haplotype assembly. It is especially suitable for long reads, but works also well with short reads.

BioContainers: https://biocontainers.pro/tools/whatshap
Home page: https://github.com/whatshap/whatshap

Link to section 'Versions' of 'whatshap' Versions

Link to section 'Commands' of 'whatshap' Commands

whatshap

Link to section 'Module' of 'whatshap' Module

You can load the modules by:

module load biocontainers
module load whatshap

Link to section 'Example job' of 'whatshap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run whatshap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=whatshap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers whatshap

whatshap phase --indels \ 
    --reference=reference.fasta \
    variants.vcf pacbio.bam

wiggletools

Link to section 'Introduction' of 'wiggletools' Introduction

The WiggleTools package allows genomewide data files to be manipulated as numerical functions, equipped with all the standard functional analysis operators (sum, product, product by a scalar, comparators), and derived statistics (mean, median, variance, stddev, t-test, Wilcoxon's rank sum test, etc).

Docker hub: https://hub.docker.com/r/ensemblorg/wiggletools
Home page: https://github.com/Ensembl/WiggleTools

Link to section 'Versions' of 'wiggletools' Versions

1.2.11

Link to section 'Commands' of 'wiggletools' Commands

wiggletools

Link to section 'Module' of 'wiggletools' Module

You can load the modules by:

module load biocontainers
module load wiggletools

Link to section 'Example job' of 'wiggletools' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run wiggletools on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=wiggletools
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers wiggletools

wiggletools test/fixedStep.wig
wiggletools test/fixedStep.bw
wiggletools test/bedfile.bg
wiggletools test/overlapping.bed
wiggletools test/bam.bam
wiggletools test/cram.cram
wiggletools test/vcf.vcf
wiggletools test/bcf.bcf

winnowmap

Link to section 'Introduction' of 'winnowmap' Introduction

Winnowmap is a long-read mapping algorithm optimized for mapping ONT and PacBio reads to repetitive reference sequences.

BioContainers: https://biocontainers.pro/tools/winnowmap
Home page: https://github.com/marbl/Winnowmap

Link to section 'Versions' of 'winnowmap' Versions

2.03

Link to section 'Commands' of 'winnowmap' Commands

winnowmap

Link to section 'Module' of 'winnowmap' Module

You can load the modules by:

module load biocontainers
module load winnowmap

Link to section 'Example job' of 'winnowmap' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run winnowmap on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=winnowmap
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers winnowmap

winnowmap -W repetitive_k15.txt \
    -ax map-pb Cm.contigs.fasta \
    SRR3982487.fastq > output.sam

wtdbg

Link to section 'Introduction' of 'wtdbg' Introduction

Wtdbg2 is a de novo sequence assembler for long noisy reads produced by PacBio or Oxford Nanopore Technologies (ONT).

For more information, please check its website: https://biocontainers.pro/tools/wtdbg and its home page on Github.

Link to section 'Versions' of 'wtdbg' Versions

Link to section 'Commands' of 'wtdbg' Commands

wtdbg-cns
wtdbg2
wtpoa-cns

Link to section 'Module' of 'wtdbg' Module

You can load the modules by:

module load biocontainers
module load wtdbg

Link to section 'Example job' of 'wtdbg' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Wtdbg2 on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 24
#SBATCH --job-name=wtdbg
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers wtdbg

wtpoa-cns -t 24 -i dbg.ctg.lay.gz -fo dbg.ctg.fa

bayescan

Link to section 'Introduction' of 'bayescan' Introduction

BayeScan aims at identifying candidate loci under natural selection from genetic data, using differences in allele frequencies between populations.

For more information, please check its home page on http://cmpg.unibe.ch/software/BayeScan/.

Link to section 'Versions' of 'bayescan' Versions

Link to section 'Commands' of 'bayescan' Commands

bayescan

Link to section 'Module' of 'bayescan' Module

You can load the modules by:

module load biocontainers
module load bayescan

Link to section 'Example job' of 'bayescan' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run bayescan on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=bayescan
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers bayescan

aspera-connect

Link to section 'Introduction' of 'aspera-connect' Introduction

Aspera connect is software that allows download and upload data. The software includes a command line tool (ascp) that allows scripted data transfer.

Link to section 'Versions' of 'aspera-connect' Versions

4.2.6

Link to section 'Commands' of 'aspera-connect' Commands

ascp
ascp4
asperaconnect
asperaconnect.bin
asperaconnect-nmh
asperacrypt
asunprotect

Link to section 'Module' of 'aspera-connect' Module

You can load the modules by:

module load biocontainers
module load aspera-connect

Link to section 'Example job' of 'aspera-connect' Example job

Using #!/bin/sh -l as shebang in the slurm job script will cause the failure of some biocontainer modules. Please use #!/bin/bash instead.

To run Abacas on our clusters:

#!/bin/bash
#SBATCH -A myallocation     # Allocation name 
#SBATCH -t 1:00:00
#SBATCH -N 1
#SBATCH -n 1
#SBATCH --job-name=abacas
#SBATCH --mail-type=FAIL,BEGIN,END
#SBATCH --error=%x-%J-%u.err
#SBATCH --output=%x-%J-%u.out

module --force purge
ml biocontainers aspera-connect

ascp -i ~/aspera.openssh -QT -l100m -k1 -d SRC DEST

Helpful?

Biocontainers

Link to section 'What is BioContainers' of 'Biocontainers' What is BioContainers

Link to section 'Deployed Applications' of 'Biocontainers' Deployed Applications

abacas

Link to section 'Introduction' of 'abacas' Introduction

Link to section 'Versions' of 'abacas' Versions

Link to section 'Commands' of 'abacas' Commands

Link to section 'Module' of 'abacas' Module

Link to section 'Example job' of 'abacas' Example job

abismal

Link to section 'Introduction' of 'abismal' Introduction

Link to section 'Versions' of 'abismal' Versions

Link to section 'Commands' of 'abismal' Commands

Link to section 'Module' of 'abismal' Module

Link to section 'Example job' of 'abismal' Example job

abpoa

Link to section 'Introduction' of 'abpoa' Introduction

Link to section 'Versions' of 'abpoa' Versions

Link to section 'Commands' of 'abpoa' Commands

Link to section 'Module' of 'abpoa' Module

Link to section 'Example job' of 'abpoa' Example job

abricate

Link to section 'Introduction' of 'abricate' Introduction

Link to section 'Versions' of 'abricate' Versions

Link to section 'Commands' of 'abricate' Commands

Link to section 'Module' of 'abricate' Module

Link to section 'Example job' of 'abricate' Example job

abyss

Link to section 'Introduction' of 'abyss' Introduction

Link to section 'Versions' of 'abyss' Versions

Link to section 'Commands' of 'abyss' Commands

Link to section 'Module' of 'abyss' Module

Link to section 'Example job' of 'abyss' Example job

actc

Link to section 'Introduction' of 'actc' Introduction

Link to section 'Versions' of 'actc' Versions

Link to section 'Commands' of 'actc' Commands

Link to section 'Module' of 'actc' Module

Link to section 'Example job' of 'actc' Example job

adapterremoval

Link to section 'Introduction' of 'adapterremoval' Introduction

Link to section 'Versions' of 'adapterremoval' Versions

Link to section 'Commands' of 'adapterremoval' Commands

Link to section 'Module' of 'adapterremoval' Module

Link to section 'Example job' of 'adapterremoval' Example job

advntr

Link to section 'Introduction' of 'advntr' Introduction

Link to section 'Versions' of 'advntr' Versions

Link to section 'Commands' of 'advntr' Commands

Link to section 'Module' of 'advntr' Module

Link to section 'Example job' of 'advntr' Example job

afplot

Link to section 'Introduction' of 'afplot' Introduction

Link to section 'Versions' of 'afplot' Versions

Link to section 'Commands' of 'afplot' Commands

Link to section 'Module' of 'afplot' Module

Link to section 'Example job' of 'afplot' Example job

afterqc

Link to section 'Introduction' of 'afterqc' Introduction

Link to section 'Versions' of 'afterqc' Versions

Link to section 'Commands' of 'afterqc' Commands

Link to section 'Module' of 'afterqc' Module

Link to section 'Example job' of 'afterqc' Example job

agat

Link to section 'Introduction' of 'agat' Introduction

Link to section 'Versions' of 'agat' Versions

Link to section 'Commands' of 'agat' Commands

Link to section 'Module' of 'agat' Module

Link to section 'Example job' of 'agat' Example job

agfusion

Link to section 'Introduction' of 'agfusion' Introduction

Link to section 'Versions' of 'agfusion' Versions

Link to section 'Commands' of 'agfusion' Commands

Link to section 'Module' of 'agfusion' Module

Link to section 'Example job' of 'agfusion' Example job

alfred

Link to section 'Introduction' of 'alfred' Introduction

Link to section 'Versions' of 'alfred' Versions

Link to section 'Commands' of 'alfred' Commands

Link to section 'Module' of 'alfred' Module