eva.config

// Profile config names for nf-core/configs

params {
    // Specific nf-core/configs params
    config_profile_contact     = 'James Fellows Yates (@jfy133)'
    config_profile_description = 'nf-core/eager EVA profile provided by nf-core/configs'
}

env {
    _JAVA_OPTIONS        = "-XX:ParallelGCThreads=1"
    OPENBLAS_NUM_THREADS = 1
    OMP_NUM_THREADS      = 1
}

// Specific nf-core/eager process configuration
process {

    maxRetries     = 2

    // Solution for clusterOptions comes from here: https://github.com/nextflow-io/nextflow/issues/332 + personal toMega conversion
    clusterOptions = { "-S /bin/bash -V -j y -o output.log -l h_vmem=${task.memory.toGiga()}G" }

    withLabel: sc_tiny {
        cpus   = { check_max(1, 'cpus') }
        memory = { check_max(1.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: sc_small {
        cpus   = { check_max(1, 'cpus') }
        memory = { check_max(4.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: sc_medium {
        cpus   = { check_max(1, 'cpus') }
        memory = { check_max(8.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: mc_small {
        cpus   = { check_max(2, 'cpus') }
        memory = { check_max(4.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: mc_medium {
        cpus   = { check_max(4, 'cpus') }
        memory = { check_max(8.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: mc_large {
        cpus   = { check_max(8, 'cpus') }
        memory = { check_max(16.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    withLabel: mc_huge {
        cpus   = { check_max(32, 'cpus') }
        memory = { check_max(256.GB * task.attempt, 'memory') }
        time   = '365.d'
    }

    // Fixes for SGE and Java incompatibility due to Java using more memory than you tell it to use

    withName: makeSeqDict {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: fastqc {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: fastqc_after_clipping {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: adapter_removal {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: bwa {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga())}G,h=!(bionode01|bionode02|bionode03|bionode04|bionode05|bionode06)" }
    }

    withName: bwamem {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga())}G,h=!(bionode01|bionode02|bionode03|bionode04|bionode05|bionode06)" }
    }

    withName: circularmapper {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga())}G,h=!(bionode01|bionode02|bionode03|bionode04|bionode05|bionode06)" }
    }

    withName: bowtie2 {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga())}G,h=!(bionode01|bionode02|bionode03|bionode04|bionode05|bionode06)" }
    }

    withName: samtools_flagstat {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
    }

    withName: samtools_flagstat_after_filter {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
    }

    withName: dedup {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: markduplicates {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        memory         = { check_max(20.GB * task.attempt, 'memory') }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: library_merge {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
    }

    withName: seqtype_merge {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
    }

    withName: additional_library_merge {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        memory         = { check_max(4.GB * task.attempt, 'memory') }
    }

    withName: metagenomic_complexity_filter {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
    }

    withName: malt {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=1000G" }
        cpus           = { check_max(32, 'cpus') }
        memory         = { check_max(955.GB * task.attempt, 'memory') }
    }

    withName: maltextract {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: multivcfanalyzer {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: mtnucratio {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: vcf2genome {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: qualimap {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : task.exitStatus in [255] ? 'ignore' : 'finish' }
    }

    withName: damageprofiler {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        memory         = { check_max(8.GB * task.attempt, 'memory') }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: circularmapper {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: circulargenerator {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: preseq {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [143, 137, 104, 134, 139] ? 'retry' : 'ignore' }
    }

    withName: picard_addorreplacereadgroups {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: genotyping_ug {
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 2)}G" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: get_software_versions {
        cache          = false
        clusterOptions = { "-S /bin/bash -V -l h=!(bionode06)" }
        clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toMega() * 8)}M" }
        errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
    }

    withName: multiqc {
        clusterOptions = { "-S /bin/bash -V -j y -o output.log -l h_vmem=${task.memory.toGiga() * 2}G" }
    }
}

profiles {

    medium_data {

        params {
            // Specific nf-core/configs params
            config_profile_contact     = 'James Fellows Yates (@jfy133)'
            config_profile_description = 'nf-core/eager medium-data EVA profile provided by nf-core/configs'
        }

        executor {
            queueSize = 8
        }

        process {

            maxRetries     = 2

            // Solution for clusterOptions comes from here: https://github.com/nextflow-io/nextflow/issues/332 + personal toMega conversion
            clusterOptions = { "-S /bin/bash -V -j y -o output.log -l h_vmem=${task.memory.toGiga()}G" }

            withLabel: sc_tiny {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(1.5.GB * task.attempt, 'memory') }
            }

            withLabel: sc_small {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(6.GB * task.attempt, 'memory') }
            }

            withLabel: sc_medium {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(12.GB * task.attempt, 'memory') }
            }

            withLabel: mc_small {
                cpus   = { check_max(2, 'cpus') }
                memory = { check_max(6.GB * task.attempt, 'memory') }
            }

            withLabel: mc_medium {
                cpus   = { check_max(4, 'cpus') }
                memory = { check_max(12.GB * task.attempt, 'memory') }
            }

            withLabel: mc_large {
                cpus   = { check_max(8, 'cpus') }
                memory = { check_max(24.GB * task.attempt, 'memory') }
            }

            withLabel: mc_huge {
                cpus   = { check_max(32, 'cpus') }
                memory = { check_max(256.GB * task.attempt, 'memory') }
            }

            // Fixes for SGE and Java incompatibility due to  (and also some samtools?!) using more memory than you tell it to use

            withName: makeSeqDict {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: fastqc {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: fastqc_after_clipping {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: adapter_removal {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: samtools_flagstat {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
            }

            withName: samtools_flagstat_after_filter {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
            }

            withName: dedup {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: markduplicates {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                memory         = { check_max(32.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: library_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
            }

            withName: seqtype_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
            }

            withName: additional_library_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                memory         = { check_max(4.GB * task.attempt, 'memory') }
            }

            withName: metagenomic_complexity_filter {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
            }

            withName: malt {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=1000G" }
                cpus           = { check_max(32, 'cpus') }
                memory         = { check_max(955.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: hostremoval_input_fastq {
                memory = { check_max(32.GB * task.attempt, 'memory') }
            }

            withName: maltextract {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: multivcfanalyzer {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: mtnucratio {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: vcf2genome {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: qualimap {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : task.exitStatus in [255] ? 'ignore' : 'finish' }
            }

            withName: damageprofiler {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                memory         = { check_max(16.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: circularmapper {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: circulargenerator {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: picard_addorreplacereadgroups {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: genotyping_ug {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: preseq {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 3)}G" }
                errorStrategy  = { task.exitStatus in [143, 137, 104, 134, 139] ? 'retry' : 'ignore' }
            }
        }
    }

    big_data {

        params {
            // Specific nf-core/configs params
            config_profile_contact     = 'James Fellows Yates (@jfy133)'
            config_profile_description = 'nf-core/eager big-data EVA profile provided by nf-core/configs'
        }

        executor {
            queueSize = 6
        }

        process {

            maxRetries     = 2

            // Solution for clusterOptions comes from here: https://github.com/nextflow-io/nextflow/issues/332 + personal toMega conversion
            clusterOptions = { "-S /bin/bash -V -j y -o output.log -l h_vmem=${task.memory.toGiga()}G" }

            withLabel: sc_tiny {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(2.GB * task.attempt, 'memory') }
            }

            withLabel: sc_small {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(8.GB * task.attempt, 'memory') }
            }

            withLabel: sc_medium {
                cpus   = { check_max(1, 'cpus') }
                memory = { check_max(16.GB * task.attempt, 'memory') }
            }

            withLabel: mc_small {
                cpus   = { check_max(2, 'cpus') }
                memory = { check_max(8.GB * task.attempt, 'memory') }
            }

            withLabel: mc_medium {
                cpus   = { check_max(4, 'cpus') }
                memory = { check_max(16.GB * task.attempt, 'memory') }
            }

            withLabel: mc_large {
                cpus   = { check_max(8, 'cpus') }
                memory = { check_max(32.GB * task.attempt, 'memory') }
            }

            withLabel: mc_huge {
                cpus   = { check_max(32, 'cpus') }
                memory = { check_max(512.GB * task.attempt, 'memory') }
            }

            // Fixes for SGE and Java incompatibility due to Java using more memory than you tell it to use

            withName: makeSeqDict {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: fastqc {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: fastqc_after_clipping {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: adapter_removal {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: samtools_flagstat {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
            }

            withName: samtools_flagstat_after_filter {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
            }

            withName: dedup {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: markduplicates {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                memory         = { check_max(48.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: library_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                memory         = { check_max(6.GB * task.attempt, 'memory') }
            }

            withName: seqtype_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
            }

            withName: additional_library_merge {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                memory         = { check_max(6.GB * task.attempt, 'memory') }
            }

            withName: hostremoval_input_fastq {
                memory = { check_max(32.GB * task.attempt, 'memory') }
            }

            withName: metagenomic_complexity_filter {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
            }

            withName: malt {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=1000G" }
                cpus           = { check_max(32, 'cpus') }
                memory         = { check_max(955.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: maltextract {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: multivcfanalyzer {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: mtnucratio {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: vcf2genome {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: qualimap {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : task.exitStatus in [255] ? 'ignore' : 'finish' }
            }

            withName: damageprofiler {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                memory         = { check_max(32.GB * task.attempt, 'memory') }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: circularmapper {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: circulargenerator {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: picard_addorreplacereadgroups {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: genotyping_ug {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [1, 143, 137, 104, 134, 139, 140] ? 'retry' : 'finish' }
            }

            withName: preseq {
                clusterOptions = { "-S /bin/bash -V -l h_vmem=${(task.memory.toGiga() * 6)}G" }
                errorStrategy  = { task.exitStatus in [143, 137, 104, 134, 139] ? 'retry' : 'ignore' }
            }
        }
    }

    pathogen_loose {
        params {
            config_profile_description = 'Pathogen (loose) MPI-EVA profile, provided by nf-core/configs.'
            bwaalnn                    = 0.01
            bwaalnl                    = 16
        }
    }
    pathogen_strict {
        params {
            config_profile_description = 'Pathogen (strict) MPI-EVA SDAG profile, provided by nf-core/configs.'
            bwaalnn                    = 0.1
            bwaalnl                    = 32
        }
    }
    human {
        params {
            config_profile_description = 'Human MPI-EVA SDAG profile, provided by nf-core/configs.'
            bwaalnn                    = 0.01
            bwaalnl                    = 16500
        }
    }
    ena_prep {
        // Profile with minimal processing within nf-core/eager to crate the FastQ/BAM files for ENA upload. This should be used with FASTQ files from Pandora.
        params {
            // Skip any statistic generation
            skip_preseq             = true
            skip_damage_calculation = true
            skip_qualimap           = true
            skip_deduplication      = true

            // Adapter removal
            skip_collapse           = true
            // No read collapsing for paired-end data.
            clip_readlength         = 1
            // If 0, then empty reads are left in, which breaks downstream processing.
            clip_min_read_quality   = 0
            // No base quality filtering.

            // Mapping
            bwaalnn                 = 0.01
        }
    }
}

// Function to ensure that resource requirements don't go beyond
// a maximum limit
// FOR DSL1 PIPELINE ONLY!
def check_max(obj, type) {
    if (type == 'memory') {
        try {
            if (obj.compareTo(params.max_memory as nextflow.util.MemoryUnit) == 1)
                return params.max_memory as nextflow.util.MemoryUnit
            else
                return obj
        } catch (all) {
            println "   ### ERROR ###   Max memory '${params.max_memory}' is not valid! Using default value: $obj"
            return obj
        }
    } else if (type == 'time') {
        try {
            if (obj.compareTo(params.max_time as nextflow.util.Duration) == 1)
                return params.max_time as nextflow.util.Duration
            else
                return obj
        } catch (all) {
            println "   ### ERROR ###   Max time '${params.max_time}' is not valid! Using default value: $obj"
            return obj
        }
    } else if (type == 'cpus') {
        try {
            return Math.min( obj, params.max_cpus as int )
        } catch (all) {
            println "   ### ERROR ###   Max cpus '${params.max_cpus}' is not valid! Using default value: $obj"
            return obj
        }
    }
}