Skip to content
hariszafPublic

About

PEMA: a flexible Pipeline for Environmental DNA Metabarcoding Analysis of the 16S/18S rRNA, ITS and COI marker genes

Resources

Contributing

Stars

33 stars

Watchers

3 watching

Forks

Repository files navigation

PEMA:

a flexible Pipeline for Environmental DNA Metabarcoding Analysis of the 16S/18S rRNA, ITS and COI marker genes

PEMA: biodiversity in all its different levels

PEMA supports the metabarcoding analysis of four marker genes, 16S rRNA (Bacteria), ITS (Fungi) as well as COI and 18S rRNA (metazoa). As input, PEMA accepts .fastq.gz files as returned by Illumina sequencing platforms.

Since the v.2.1.4 release, PEMA supports also the analysis of the 12S rRNA marker gene!

PEMA processes the reads from each sample and returns an OTU- or an ASV-table with the taxonomies of the taxa found and their abundances in each sample, along with quality reports for the reads of each sample.

Since v3.0.0, PEMA is a Nextflow pipeline. Every step runs in its own container, so the only requirements are Nextflow and a container engine (Docker, Podman, Singularity or Apptainer).

What the Nextflow pipeline does

Step Tool Container
Primer removal (ITS only) cutadapt quay.io/biocontainers/cutadapt
Quality control and merging of paired-end reads fastp quay.io/biocontainers/fastp
Dereplication per sample VSEARCH quay.io/biocontainers/vsearch
Hashing of the unique sequences and contingency table across samples PEMA scripts hariszaf/pema-nf
ASV inference, or Swarm v3 quay.io/biocontainers/swarm
ASV inference (on the read pairs, merged after denoising), or DADA2 quay.io/biocontainers/bioconductor-dada2
OTU clustering, with de novo chimera removal VSEARCH quay.io/biocontainers/vsearch
Removal of oligotons (low-abundance ASVs or amplicons) and ASV/OTU tables PEMA scripts hariszaf/pema-nf
Taxonomy assignment crest4 or RDPClassifier hariszaf/crest4, quay.io/biocontainers/rdp_classifier
Mapping to NCBI Taxonomy (optional) NCBI Datasets CLI staphb/ncbi-datasets, hariszaf/pema-nf

Supported: clustering_algo: swarm (ASVs), clustering_algo: dada2 (ASVs) or clustering_algo: vsearch (OTUs), and classifier: crest or classifier: rdp, in any combination.

How to run PEMA

Requirements

  • Nextflow 25.04 or later (tested with 26.04)
  • One of: Docker (default), Podman, Singularity or Apptainer

All container images are pulled automatically on the first run.

Input data

A folder (raw_reads) with paired-end fastq files (.fastq, .fq, .fastq.gz or .fq.gz). Other files in the folder are ignored.

The two files of a pair are recognised by a 1/2 (or R1/R2, any case) between separators (_, . or -) in their names; the last such marker in the name is used, and the part before it becomes the sample name. For example:

Read 1 Read 2 Sample
S1_1.fastq.gz S1_2.fastq.gz S1
S1_R1.fq.gz S1_R2.fq.gz S1
S1.R1.fastq S1.R2.fastq S1
S1_S1_L001_R1_001.fastq.gz S1_S1_L001_R2_001.fastq.gz S1_S1_L001
site_1_1.fastq.gz site_1_2.fastq.gz site_1

PEMA stops before running anything, and lists all the problems found, if:

  • the folder does not exist or contains no fastq files;
  • a file has no 1/2 marker, or no sample name before it;
  • a file has no mate, or two files claim to be the same read of a sample;
  • two pairs end up with the same sample name (e.g. S1_R1_001 and S1_R1_002).

Sample names may not contain whitespace. Samples sequenced on several lanes (_L001, _L002, ...) are treated as separate samples.

Run

Copy pema.yaml, set raw_reads and outdir, adjust the parameters (see below), and run from the root folder of this repository:

nextflow run pema.nf --params-file pema.yaml

To use another container engine, add a profile:

nextflow run pema.nf --params-file pema.yaml -profile singularity

Available profiles: docker (default), podman, singularity, apptainer. Adding the reports profile (e.g. -profile docker,reports) writes a Nextflow timeline, report and trace in pipeline_info/, with the time, CPU and memory of every step.

Note: the parameters are given with --params-file (two dashes), which PEMA reads itself. Nextflow's own -params-file (single dash) is a different option.

Resume a run

You do not have to run the whole analysis again to change part of it. Nextflow keeps the result of every step in the work/ folder; add -resume and only the steps whose input, parameters or code changed are run again, the others are reused (they show as cached):

nextflow run pema.nf --params-file pema.yaml -resume

For example, after a run with crest4:

  • another classifier or database: change classifier (or the database) in the parameters file and resume; quality control, denoising/clustering and the ASV/OTU table are reused, and only the taxonomy assignment runs again;
  • adding NCBI Taxonomy: set get_ncbi_taxonomy: true and resume; only the NCBI steps run;
  • another clustering setting (e.g. Swarm's differences): clustering and everything after it run again, quality control is reused;
  • an interrupted run (Ctrl+C, a crash, or "too many requests" errors of the NCBI step): resume, and PEMA continues from where it stopped.

Each step only reads its own section of the parameters file, so changing one section does not re-run the other steps. What -resume needs:

  • run it from the same folder as before, so Nextflow finds the same work/ folder and run history (.nextflow/); do not delete work/ (or run nextflow clean) while you may still want to resume;
  • the results of the new run are written to outdir, over the previous ones; to keep both, set a different outdir (e.g. results_rdp): this does not affect what is reused.

nextflow log lists the previous runs of a folder.

The parameters file

All parameters live in one YAML file; pema.yaml documents each of them. Parameters left empty are not passed to the tool, so the tool's own default applies.

Section / key Description Default
raw_reads Folder with the paired-end fastq files (see Input data) required
marker_gene 16S, 18S, 12S, COI or ITS required
outdir Output folder results
threads Threads for fastp, Swarm and crest4 3
clustering_algo swarm, dada2 or vsearch swarm
classifier crest or rdp crest
min_oligotons Abundance below which ASVs (Swarm) or amplicons (VSEARCH) are removed; 0 keeps all 5
cutadapt forward_primer, reverse_primer and any other cutadapt option required for ITS
fastp Any fastp option, without the leading -- required
swarm Any Swarm option, e.g. differences, fastidious required for Swarm
vsearch threshold: identity threshold for the OTU clustering; min_oligotons for VSEARCH only 0.97; the global min_oligotons
dada2 trunc_len_forward, trunc_len_reverse, pool, min_overlap, max_mismatch, chimera_method, nbases see the YAML file
crest database, mount_crest_dbs, search_algo, min_score, min_smlrty, score_drop, threads, and train for a custom database see the YAML file
rdp database, databases_dir, confidence, memory, and train for a custom database see the YAML file
ncbi_taxonomy get_ncbi_taxonomy, ncbi_api_key, max_parallel, sleep off when missing

ITS. With marker_gene: ITS, the primers are removed with cutadapt from the raw read pairs, before fastp. ITS amplicons vary in length, so reads often run into the opposite primer: read 1 is trimmed of the forward primer and of the reverse complement of the reverse primer, and read 2 of the reverse primer and of the reverse complement of the forward primer (as in the DADA2 ITS workflow). This has to happen while the reads are still pairs, before fastp trims and merges them. IUPAC ambiguity codes are allowed in the primers.

PEMA adjusts some values to keep the tools consistent:

  • With Swarm, fastp's n_base_limit is set to 0 (Swarm does not accept Ns).
  • Swarm's fastidious options (fastidious, boundary, ceiling, bloom-bits) are only used when differences is 1, and the pairwise alignment options (match-reward, mismatch-penalty, gap-opening-penalty, gap-extension-penalty) only when it is larger than 1.

DADA2. With clustering_algo: dada2, the ASVs are inferred with DADA2, as in its tutorial: fastp filters the read pairs without merging them, DADA2 learns the error rates and denoises the forward and the reverse reads separately (on all samples together), merges the denoised pairs (mergePairs) and removes the chimeras. Merging before denoising would change the quality scores DADA2's error model relies on. min_oligotons then removes the ASVs with a lower total abundance. The options are in the dada2 section (pool, min_overlap, max_mismatch, chimera_method, nbases); to truncate the reads to fixed lengths, as DADA2 recommends, set trunc_len_forward and trunc_len_reverse (applied by fastp, only for DADA2).

Oligotons. With Swarm, min_oligotons applies to whole ASVs, after clustering. With VSEARCH it applies to individual amplicons (unique sequences) before clustering, as in PEMA v2.x and the VSEARCH pipeline, so it removes many more reads: with VSEARCH, a low value (e.g. 2) is usually preferable; set it in the vsearch section, so it applies to VSEARCH only.

CREST databases. database is one of crest4's built-in databases (ssuome, silvamod138pr2, mitofish, midori253darn) or the name of a folder with a custom database. For a custom database, mount_crest_dbs must point to the folder that contains it, for example:

~/.crest4/
├── silvamod138pr2/
└── unite_19_02_2025/
    ├── unite_19_02_2025.fasta
    ├── unite_19_02_2025.map
    ├── unite_19_02_2025.names
    ├── unite_19_02_2025.tre
    └── unite_19_02_2025.tsv

Setting mount_crest_dbs is also recommended for the built-in databases, so they are downloaded only once.

PEMA's own crest4 databases, currently unite2025 (UNITE, for ITS), are downloaded from Zenodo into mount_crest_dbs the first time they are used (DOWNLOAD_CREST_DB, from <download_url>/<database>.tar.gz), and reused afterwards. Their files are renamed after the database folder, as crest4 requires.

Building a custom CREST database. Set crest.train.taxonomy and crest.train.sequences, mount_crest_dbs, and database to the name of the new database. If that database is not yet in mount_crest_dbs, PEMA builds it there (PREPARE_CREST_TRAINING, TRAIN_CREST_DB) and then uses it; later runs reuse it. The database is built for crest4 with scripts/make_new_crest_db.py (the .map, .names and .tre files) and its search index is built too. The two files are:

  • a taxonomy file: tab-separated, no header, one line per sequence: accession, lineage, and optionally a name. The lineage is separated by / (crest4; e.g. exported from ARB, starting with Main genome/) or by ; (the .nds files of the previous CREST versions):
    SSEQ_1   Bacteria;Firmicutes;Bacilli;Bacillales;Bacillaceae;Bacillus;Bacillus_vallismortis   SSEQ_1
    
  • a sequence file: fasta, the first word of each header being the accession. Unlike older CREST versions, crest4 does not need an alignment (gaps are removed if there are any).

Each rank gets a minimum similarity for an assignment to it: 0.99 for the deepest rank (e.g. species), then 0.02 less per rank up (0.97 genus, 0.95 family, ...), and none for the first two ranks below the root (in ARB lineages, Main genome and the domain). sanity_check/custom_crest/custom_ref_db/ contains a small example.

RDPClassifier databases. RDPClassifier needs an RDP-trained database: a folder with an rRNAClassifier.properties file and the files it lists, for example:

rdp_databases/
└── 12S_v200/
    ├── bergeyTrainingTree.xml
    ├── genus_wordConditionalProbList.txt
    ├── logWordPrior.txt
    ├── rRNAClassifier.properties
    └── wordConditionalProbIndexArr.txt

Set database to the folder name and databases_dir to the folder that contains it (here rdp_databases), or database to the full path. The PEMA-trained databases 12S_v200 (12S; 12S_v2.0.0 also works), midori_1 and midori_2 (COI) are downloaded from Zenodo into databases_dir the first time they are used (DOWNLOAD_RDP_DB), and reused afterwards. They are fetched as <download_url>/<database>.tar.gz (download_url in the rdp section). Ranks are kept from the top down while RDPClassifier's confidence is at least confidence (default 0.8; for short amplicons a lower value such as 0.5 is common). Rank prefixes such as g__ and placeholder ranks such as k__undef_Eukaryota are removed from the taxonomy.

Training RDPClassifier on a custom database. Set rdp.train.taxonomy and rdp.train.sequences, databases_dir, and database to the name of the new database. If that database is not yet in databases_dir, PEMA trains it there (PREPARE_RDP_TRAINING, TRAIN_RDP_DB) and then uses it; later runs reuse it. The two files are prepared as described in the PEMA documentation:

  • a taxonomy file: tab-separated, with a header line; an id column, then one column per rank, with an entry for every rank on every line
    Seq_ID      Kingdom    Phylum     Class       Order     Family     Genus    Species
    SEQ1179093  Eukaryota  Annelida   Polychaeta  Eunicida  Eunicidae  Eunice   Eunice_vittata
    
  • a sequence file: fasta, the first word of each header being the id used in the taxonomy file.

PEMA checks both files before training and lists any problem: missing ranks, sequences without a taxonomy, and taxon names that appear at the same rank under different parent lineages (e.g. the genus Thalia, both an animal and a plant), which RDPClassifier does not allow. Set rename_duplicates: true to rename those to <name>_1, <name>_2, ... instead. Training large databases needs a lot of memory (train.memory; MIDORI needed more than 50 GB). sanity_check/custom_rdp/custom_ref_db/ contains a small example.

NCBI Taxonomy. With get_ncbi_taxonomy: true, the lowest taxon of each assignment is looked up in NCBI Taxonomy and the NCBI lineage and taxids are added to the final table. NCBI allows 5 requests per second without an API key and 10 with one, so the key is optional: without it, up to 2 queries run at once, and with it up to 4 (max_parallel, capped to these to stay within the limits). Get an API key and preferably provide it through an environment variable, to keep it out of your configuration files:

export NCBI_API_KEY=<your key>

Output

See output_descr.md for a description of every output file. The main result is crest_assignment/tax_assigned_table.tsv or rdp_assignment/tax_assigned_table.tsv (ASV abundances per sample with their taxonomy), or ncbi_taxonomy/tax_assigned_with_ncbi.tsv when the NCBI Taxonomy step is enabled.

Running single modules

Some modules in modules/ can also be run on their own, to test a step on small data: fastp, Swarm and crest4 (CREST taxonomy assignment). Their parameters files are in tests/configs/ and their input data in tests/data/ (see tests/README.md). From the root folder of this repository:

nextflow run modules/fastp.nf --params-file tests/configs/fastp.yaml -c nextflow.config
nextflow run modules/swarm.nf --params-file tests/configs/swarm.yaml -c nextflow.config
nextflow run modules/crest.nf --params-file tests/configs/crest.yaml -c nextflow.config

The outputs are written in tests/results/ (git-ignored). Add -c nextflow.config: when a module is run directly, Nextflow does not load the root nextflow.config, so containers would be disabled. The crest4 test classifies ITS sequences with the unite2025 database: set mount_crest_dbs in tests/configs/crest.yaml to the folder that has it. See modules/README.md for notes on developing the pipeline.

Running the tests

On every push and pull request, GitHub Actions (.github/workflows/tests.yml) lints the pipeline and runs two tests of the sanity check, COI-rdp-custom and COI-crest-custom, which need no external database. Other tests can be run from the Actions tab ("Run workflow"), with the list of tests to run.

Both can also be run on your computer: the sanity check itself, or the whole CI workflow.

Running the sanity check locally

sanity_check/run_sanity_check.sh runs PEMA on a small dataset for each marker gene, with different clustering algorithms and classifiers, and reports which cases work. Run it before a release, or to check that a change breaks nothing. You need Nextflow and Docker (or another container engine, see --profile).

For each test, the script:

  1. downloads and extracts the sanity dataset into sanity_check/ (~280 MB), if it is not there yet;
  2. writes a parameters file from pema.yaml, with the reads, marker gene, clustering algorithm, classifier and database of the test (so the tests always use the current parameters file);
  3. runs pema.nf in sanity_check/<marker>/;
  4. checks that the final table (tax_assigned_table.tsv) exists and has ASVs/OTUs, and counts how many have a taxonomy.

It ends with a summary, one line per test (OK, FAILED or SKIPPED, the time, and the number of ASVs/OTUs), and exits with an error if a test failed. The files of a test are in sanity_check/<marker>/:

File Content
TEST_<marker>_FASTP_<clustering>_<classifier>/ the output of PEMA (see output_descr.md)
TEST_<...>.yaml the parameters file of the test
TEST_<...>.log the Nextflow log of the run: look here when a test fails
work/ Nextflow's intermediate files (can be deleted)

The tests:

Test Marker Clustering Classifier and database Needs
16S 16S Swarm crest4, silvamod138pr2 the crest4 SILVA database (~4 GB, downloaded on first use)
18S 18S Swarm crest4, silvamod138pr2 as 16S
12S 12S Swarm crest4, mitofish the crest4 MitoFish database (downloaded on first use)
COI COI Swarm crest4, midori253darn the crest4 MIDORI database (~3 GB, downloaded on first use)
ITS ITS cutadapt, Swarm crest4, unite2025 PEMA's UNITE database (12 MB, downloaded on first use)
16S-vsearch 16S VSEARCH crest4, silvamod138pr2 as 16S
18S-vsearch 18S VSEARCH crest4, silvamod138pr2 as 16S
16S-dada2 16S DADA2 crest4, silvamod138pr2 as 16S; the slowest test (~15-20 min)
12S-rdp 12S Swarm RDPClassifier, 12S_v200 PEMA's 12S database (30 MB, downloaded on first use)
COI-rdp COI Swarm RDPClassifier, MIDORI RDP_COI_DB=midori_1 or midori_2 (downloaded on first use; >= 20 GB of memory); skipped otherwise
COI-rdp-custom COI Swarm RDPClassifier, trained on sanity_check/custom_rdp/custom_ref_db/ nothing: trains its own database (also run by CI)
COI-crest-custom COI Swarm crest4, built from sanity_check/custom_crest/custom_ref_db/ nothing: builds its own database (also run by CI)

Running specific tests. From the root folder of this repository, give the tests to run; without tests, all of them run:

# one test
sanity_check/run_sanity_check.sh 16S

# several tests
sanity_check/run_sanity_check.sh 16S 16S-vsearch 16S-dada2

# the tests that need no external database (as CI)
sanity_check/run_sanity_check.sh COI-rdp-custom COI-crest-custom

# all the tests
sanity_check/run_sanity_check.sh

Options, given before the tests:

# also test the mapping to NCBI Taxonomy (set NCBI_API_KEY to go faster)
sanity_check/run_sanity_check.sh --ncbi 18S-vsearch

# with Singularity (or podman, apptainer) instead of Docker
sanity_check/run_sanity_check.sh --profile singularity 16S

# resume the previous runs of these tests, e.g. after a failure (only what changed is run again)
sanity_check/run_sanity_check.sh --resume 16S-dada2

# add the NCBI Taxonomy step to a previous run, without running the rest again
sanity_check/run_sanity_check.sh --resume --ncbi 16S-dada2

Note: without --resume, a test starts from scratch: its output folder is deleted and every step runs again.

Environment variables choose where the databases are and which ones some tests use:

Variable Default
CREST_DBS ~/.crest4 folder of the crest4 databases; they are downloaded there once
ITS_CREST_DB unite2025 crest4 database of the ITS test, in CREST_DBS
RDP_DBS sanity_check/rdp_dbs folder of the RDPClassifier databases; the PEMA-trained ones are downloaded there once
RDP_12S_DB 12S_v200 RDPClassifier database of the 12S-rdp test
RDP_COI_DB (none) RDPClassifier database of the COI-rdp test, e.g. midori_1; without it, COI-rdp is skipped

for example:

# COI with RDPClassifier and MIDORI 1
RDP_COI_DB=midori_1 sanity_check/run_sanity_check.sh COI-rdp

# ITS with a crest4 database of your own, in /data/crest4/my_unite
CREST_DBS=/data/crest4 ITS_CREST_DB=my_unite sanity_check/run_sanity_check.sh ITS

# the crest4 databases somewhere else than ~/.crest4
CREST_DBS=/scratch/crest4 sanity_check/run_sanity_check.sh 16S 18S

sanity_check/run_sanity_check.sh --help lists all this too.

Testing your version of the code, as CI does. The scripts of scripts/ run in the pema-nf image; to test your changes to them, build the image from your copy of the repository, with the tag the modules use (otherwise it is pulled from Docker Hub), and lint the pipeline:

for tag in $(grep -rhoE 'hariszaf/pema-nf:[0-9.]+' modules/ | sort -u); do
    docker build -f containers/Dockerfile.pema_nf -t "$tag" .
done
nextflow lint pema.nf modules/ nextflow.config

Running the CI workflow locally

To check the CI workflow itself (e.g. after changing .github/workflows/tests.yml), run it with act, which runs GitHub Actions workflows on your computer. You need Docker (usable without sudo), Java 17 or later, and act.

  1. Get act, once. It is a single file, no installation or sudo needed; e.g. in ~/bin:
    mkdir -p ~/bin && curl -sL https://github.com/nektos/act/releases/latest/download/act_Linux_x86_64.tar.gz | tar xz -C ~/bin act
    ~/bin/act --version
    (for macOS or Windows, see the act releases).
  2. Run the workflow, from the root folder of this repository (act takes the folder it is run from as the repository):
    ~/bin/act push -W .github/workflows/tests.yml -P ubuntu-latest=-self-hosted
    This runs what GitHub runs on a push: the lint job, then the two sanity tests (about 10 minutes). It worked if every job ends with 🏁 Job succeeded, and act exits without an error. The first time, act may ask which default image to use; any answer works.
  3. To run other tests, as with "Run workflow" on the Actions tab:
    ~/bin/act workflow_dispatch --input tests="16S 18S-vsearch" -W .github/workflows/tests.yml -P ubuntu-latest=-self-hosted
    These download the crest4 databases they need on first use (SILVA is ~4 GB).
  4. Clean up: act keeps a folder for each job it ran in ~/.cache/act/<id>/ (a copy of the repository with the test outputs, a few GB each); delete those when you are done. Keep ~/.cache/act/actions-*, ~/.cache/act/tool_cache and ~/.cache/actcache (the GitHub actions, Java and the caches), which act reuses.

Notes:

  • -P ubuntu-latest=-self-hosted runs the steps directly on your computer instead of in a container: the tests start Docker containers themselves, which does not work from inside act's own containers. The steps need no sudo.
  • act runs your working copy, including changes you have not committed.
  • Do not use -n (dry run) with -self-hosted: in this mode the steps run anyway.
  • The actions/setup-java step writes Maven settings in ~/.m2/ (settings.xml, toolchains.xml).
  • The punycode deprecation messages come from the Node.js that act uses to run the GitHub actions, and can be ignored.

PEMA website along with how to documentation can be found here.

Its sources are in docs/ (a Jekyll site); changes merged into main are published there automatically by the docs workflow, through hariszaf/pema_documentation.

To build and preview them on your computer, use Jekyll with Ruby (option 1), or Docker (option 2).

Option 1: Jekyll. The site uses the same Jekyll version and plugins as GitHub Pages (the github-pages gem, listed in docs/Gemfile), which need Ruby 3.3, as GitHub Pages uses (Ruby 4 does not work with them).

  1. Install Ruby 3.3 with its development files and a C compiler, which some gems need to build. If your system's Ruby is another version (e.g. Fedora 44 ships Ruby 4), install 3.3 with a version manager such as rbenv:

    # the compiler and libraries to build Ruby, e.g. on Fedora:
    sudo dnf install gcc make openssl-devel libyaml-devel readline-devel zlib-devel libffi-devel
    # or on Debian/Ubuntu:
    sudo apt install build-essential libssl-dev libyaml-dev libreadline-dev zlib1g-dev libffi-dev
    
    rbenv install 3.3.6
    cd docs && rbenv local 3.3.6      # use Ruby 3.3 in docs/ only

    On macOS, brew install rbenv ruby-build gives you rbenv.

  2. Install the gems, in docs/vendor/ (git-ignored):

    cd docs
    gem install bundler
    bundle config set --local path vendor/bundle
    bundle install
  3. Build and serve the site:

    bundle exec jekyll serve

    and open http://localhost:4000/pema_documentation/; the pages are rebuilt as you edit them (Ctrl+C to stop). bundle exec jekyll build only builds it, in docs/_site/.

Option 2: Docker. Without installing Ruby, from the root folder of this repository:

docker run --rm -it -p 4000:4000 -u $(id -u):$(id -g) -v "$PWD/docs":/srv/jekyll jekyll/jekyll:pages jekyll serve --host 0.0.0.0

and open http://localhost:4000/pema_documentation/.

The documentation of the Nextflow-based PEMA is in docs/, and that of PEMA v2.x in docs/v2/.

Contact

For any troubles you may have when running PEMA or for any potential improvevments you would like to suggest, please share on the PEMA Gitter community.

Gitter License: GPL v3

This is PEMA v3, written in Nextflow. The BigDataScript-based PEMA (v1.x and v2.x), with its Docker and Singularity images and its parameters.tsv file, is available with the v.2.1.5 tag and the v2.2.0 tag; see the CHANGELOG for what changed.

License

PEMA is under the GNU GPLv3 license (for 3rd party components separate licenses apply).

Citation

Haris Zafeiropoulos, Ha Quoc Viet, Katerina Vasileiadou, Antonis Potirakis, Christos Arvanitidis, Pantelis Topalis, Christina Pavloudi, Evangelos Pafilis, PEMA: a flexible Pipeline for Environmental DNA Metabarcoding Analysis of the 16S/18S ribosomal RNA, ITS, and COI marker genes, GigaScience, Volume 9, Issue 3, March 2020, giaa022, https://doi.org/10.1093/gigascience/giaa022

About

PEMA: a flexible Pipeline for Environmental DNA Metabarcoding Analysis of the 16S/18S rRNA, ITS and COI marker genes

Resources

Contributing

Stars

33 stars

Watchers

3 watching

Forks

Releases

Packages

Used by

Contributors

Languages