From 9a8717635efb110be3704854f06c196a6ce3c15b Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 16 Jun 2026 20:33:31 +0200
Subject: [PATCH 01/80] added SPIT as DTU module

---
 .gitignore                           |   3 +
 configs/template.json                |  12 +-
 configs/template_base_commented.json |  15 +-
 configs/template_clean.json          |  12 +-
 configs/tutorial_exhaustive.json     |  25 +-
 containers/apptainer/spit_DTU.def    |  23 ++
 docs/source/workflows.rst            |   8 +-
 envs/spit_DTU.yaml                   |  19 ++
 profile_nextflow/nextflow.config     |   2 +-
 scripts/Analysis/DTU/SPIT.py         | 330 +++++++++++++++++++++++++++
 workflows/spit_DTU.nf                | 270 ++++++++++++++++++++++
 workflows/spit_DTU.smk               | 168 ++++++++++++++
 12 files changed, 879 insertions(+), 8 deletions(-)
 create mode 100644 containers/apptainer/spit_DTU.def
 create mode 100644 envs/spit_DTU.yaml
 create mode 100644 scripts/Analysis/DTU/SPIT.py
 create mode 100644 workflows/spit_DTU.nf
 create mode 100644 workflows/spit_DTU.smk

diff --git a/.gitignore b/.gitignore
index d1f3fcb2..7d38c430 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,3 +108,6 @@ venv.bak/
 
 # singularity
 *.sif
+
+# AI
+.abacusai/
diff --git a/configs/template.json b/configs/template.json
index ad52f0ed..df2c2bfc 100644
--- a/configs/template.json
+++ b/configs/template.json
@@ -440,7 +440,8 @@
         "TOOLS" :
         {
             "dexseq"  : "Analysis/DTU/DEXSEQ.R",
-            "drimseq"  : "Analysis/DTU/DRIMSEQ.R"
+            "drimseq"  : "Analysis/DTU/DRIMSEQ.R",
+            "spit"  : "Analysis/DTU/SPIT.py"
         },
         "COMPARABLE" :
         {
@@ -468,6 +469,15 @@
                         }
                     },
                     "drimseq":
+                    {
+                        "OPTIONS":
+                        {
+                            "INDEX": "",  # salmon index options
+                            "QUANT": "--validateMappings --seqBias --gcBias",  # salmon quant options
+                            "DTU": ""  # Options for Analysis
+                        }
+                    },
+                    "spit":
                     {
                         "OPTIONS":
                         {
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index 93928bb8..32b5987e 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -507,7 +507,8 @@
   "DTU": {
     "TOOLS": {
       "dexseq": "Analysis/DTU/DEXSEQ.R",
-      "drimseq": "Analysis/DTU/DRIMSEQ.R"
+      "drimseq": "Analysis/DTU/DRIMSEQ.R",
+      "spit": "Analysis/DTU/SPIT.py"
     },
     "ENV" : "",
     "BIN" : "",
@@ -544,6 +545,18 @@
           "QUANT": "--validateMappings --seqBias --gcBias",
           "DTU": ""
       }
+    },
+    "spit": {
+      "comment": {
+          "INDEX": "salmon index options, e.g. path to decoy file",
+          "QUANT": "salmon quant options",
+          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ..."
+      },
+      "OPTIONS": {
+          "INDEX": "-d GENOMES/salmon_decoy",
+          "QUANT": "--validateMappings --seqBias --gcBias",
+          "DTU": ""
+      }
     }
   }
 }
diff --git a/configs/template_clean.json b/configs/template_clean.json
index 78ea39f1..7d5d4267 100644
--- a/configs/template_clean.json
+++ b/configs/template_clean.json
@@ -413,7 +413,8 @@
   "DTU": {
     "TOOLS": {
       "dexseq": "Analysis/DTU/DEXSEQ.R",
-      "drimseq": "Analysis/DTU/DRIMSEQ.R"
+      "drimseq": "Analysis/DTU/DRIMSEQ.R",
+      "spit": "Analysis/DTU/SPIT.py"
     },
     "COMPARABLE": {
       "WTvsKO": [
@@ -442,6 +443,15 @@
             }
         },
         "drimseq": 
+        {
+            "OPTIONS":
+            {
+                "INDEX": "",
+                "QUANT": "--validateMappings --seqBias --gcBias",
+                "DTU": ""
+            }
+        },
+        "spit": 
         {
             "OPTIONS":
             {
diff --git a/configs/tutorial_exhaustive.json b/configs/tutorial_exhaustive.json
index da2cecac..8ad239ac 100644
--- a/configs/tutorial_exhaustive.json
+++ b/configs/tutorial_exhaustive.json
@@ -504,7 +504,8 @@
         "TOOLS" :
         {
             "dexseq" : "Analysis/DTU/DEXSEQ.R",
-            "drimseq" : "Analysis/DTU/DRIMSEQ.R"
+            "drimseq" : "Analysis/DTU/DRIMSEQ.R",
+            "spit" : "Analysis/DTU/SPIT.py"
         },
         "COMPARABLE" :
         {
@@ -535,6 +536,17 @@
                             "QUANT": "",  # Options for read counting, independent of COUNTS workflows
                             "DTU": "min_samps_feature_expr = 1, min_feature_expr = .1,  min_samps_gene_expr = 1, min_gene_expr = 1"  # Options for DE Analysis
                         }
+                    },
+                    "spit": {
+                        "REFERENCE": "GENOMES/Ecoli/Ecoli_trans.fa.gz",
+                        "ANNOTATION": "GENOMES/Ecoli/Ecoli_trans_fix.gtf.gz",
+                        "DECOY": "GENOMES/Ecoli/salmon_decoy",
+                        "OPTIONS":
+                        {
+                            "INDEX": "",
+                            "QUANT": "",  # Options for read counting, independent of COUNTS workflows
+                            "DTU": ""  # Options for DE Analysis
+                        }
                     }
                 }
             },
@@ -560,6 +572,17 @@
                         "QUANT": "", # Options for read counting, independent of COUNTS workflows
                         "DTU": "min_samps_feature_expr = 1, min_feature_expr = .1,  min_samps_gene_expr = 1, min_gene_expr = 1"  # Options for DE Analysis
                     }
+                },
+                "spit": {
+                    "REFERENCE": "GENOMES/Ecoli/Ecoli_trans.fa.gz",
+                    "ANNOTATION": "GENOMES/Ecoli/Ecoli_trans_fix.gtf.gz",
+                    "DECOY": "GENOMES/Ecoli/salmon_decoy",
+                    "OPTIONS":
+                    {
+                        "INDEX": "",  
+                        "QUANT": "", # Options for read counting, independent of COUNTS workflows
+                        "DTU": ""  # Options for DE Analysis
+                    }
                 }
             }
         }
diff --git a/containers/apptainer/spit_DTU.def b/containers/apptainer/spit_DTU.def
new file mode 100644
index 00000000..f228de5a
--- /dev/null
+++ b/containers/apptainer/spit_DTU.def
@@ -0,0 +1,23 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+   
+%files
+    /home/fall/MONSDA/envs/spit_DTU.yaml /opt/envs/
+    ${HOME}/MONSDA/scripts /opt/MONSDA/
+
+%environment
+   
+%post
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/spit_DTU.yaml
+    
+    ENV_NAME=spit_DTU
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+   
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/spit_DTU.yaml -p /opt/conda/envs/$ENV_NAME
+    conda clean --all
+   
+%runscript
+    exec "$@"
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index 008756bc..d9b75814 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -231,9 +231,11 @@ Includes DE, DEU, DAS and DTU
   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
   | DIEGO     | Differential Alternative Splicing   |                  |                 |                | Mann-Whitney U test             | pValue         | results                                              |                                         | Sig                                     | Dendrogram-plot   |                                                                   | ✓     |
   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | DRIMSeq   | Differential Transcript Usage       | dmFilter()       |                 | DM             |                                 | pValue, LFC    | results(transcript, genes)                           | Proportions-table, genewise precision   | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | FeatPerGene, precision, Pvalues (per comparison)                  | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  
+   | DRIMSeq   | Differential Transcript Usage       | dmFilter()       |                 | DM             |                                 | pValue, LFC    | results(transcript, genes)                           | Proportions-table, genewise precision   | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | FeatPerGene, precision, Pvalues (per comparison)                  | ✓     |
+   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
+   | SPIT      | Differential Transcript Usage       | IF-dominance     |                 | KDE            | Mann-Whitney U                  | pValue, LFC    | results(transcript, genes, ifs)                      | IF-table                                | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | PValues, Wasserstein (per comparison)                             | ✓     |
+   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
+   
 TRACKS
 ###############
 
diff --git a/envs/spit_DTU.yaml b/envs/spit_DTU.yaml
new file mode 100644
index 00000000..e6a7c3ec
--- /dev/null
+++ b/envs/spit_DTU.yaml
@@ -0,0 +1,19 @@
+name: spit_DTU
+channels:
+  - bioconda
+  - conda-forge
+  - nodefaults
+dependencies:
+  - python >=3.9
+  - pandas >=1.3.4
+  - numpy >=1.20.3
+  - scipy >=1.11.1
+  - scikit-learn >=1.1.1
+  - matplotlib-base >=3.4.3
+  - matplotlib-venn >=0.11.6
+  - seaborn >=0.11.2
+  - tqdm >=4.62.3
+  - sed=4.8
+  - pip
+  - pip:
+    - spit
diff --git a/profile_nextflow/nextflow.config b/profile_nextflow/nextflow.config
index 6d15e289..bc36eb4b 100644
--- a/profile_nextflow/nextflow.config
+++ b/profile_nextflow/nextflow.config
@@ -33,7 +33,7 @@ profiles {
                 queue  = 'medium'
                 time   = { 18.h * (1 << ((task.attempt ?: 1) - 1)) }
             }
-            withName: 'run_drimseq|run_dexseq' {
+            withName: 'run_drimseq|run_dexseq|run_spit' {
                 memory = { 40.GB * (1 << ((task.attempt ?: 1) - 1)) }
                 queue  = 'long'
                 time   = { 120.h * (1 << ((task.attempt ?: 1) - 1)) }
diff --git a/scripts/Analysis/DTU/SPIT.py b/scripts/Analysis/DTU/SPIT.py
new file mode 100644
index 00000000..8a354203
--- /dev/null
+++ b/scripts/Analysis/DTU/SPIT.py
@@ -0,0 +1,330 @@
+#! /usr/bin/env python3
+
+import sys
+import os
+import inspect
+import gzip
+import re
+import shutil
+import pickle
+import logging
+import subprocess
+import traceback as tb
+
+import numpy as np
+import pandas as pd
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+cmd_subfolder = os.path.join(
+    os.path.dirname(
+        os.path.realpath(os.path.abspath(inspect.getfile(inspect.currentframe())))
+    ),
+    "../lib",
+)
+if cmd_subfolder not in sys.path:
+    sys.path.insert(0, cmd_subfolder)
+
+from Logger import *
+
+scriptname = os.path.basename(inspect.stack()[-1].filename).replace(".py", "")
+
+
+def read_quant(path):
+    logid = scriptname + ".read_quant: "
+    if os.path.isdir(path):
+        qf = os.path.join(path, "quant.sf.gz")
+        if not os.path.exists(qf):
+            qf = os.path.join(path, "quant.sf")
+    else:
+        qf = path
+    log.debug(logid + "reading " + str(qf))
+    comp = "gzip" if str(qf).endswith(".gz") else None
+    df = pd.read_csv(qf, sep="\t", compression=comp)
+    df["Name"] = [re.sub(r"\.[0-9]+$", "", str(x)) for x in df["Name"]]
+    s = df.set_index("Name")["NumReads"]
+    s = s.groupby(level=0).sum()
+    return s
+
+
+def parse_tx2gene(gtf):
+    logid = scriptname + ".parse_tx2gene: "
+    tx2gene = {}
+    gene2name = {}
+    opn = gzip.open if str(gtf).endswith(".gz") else open
+    with opn(gtf, "rt") as fh:
+        for line in fh:
+            if line.startswith("#"):
+                continue
+            cols = line.rstrip("\n").split("\t")
+            if len(cols) < 9:
+                continue
+            attr = cols[8]
+            tid = re.search(r'transcript_id "?([^";]+)"?', attr)
+            gid = re.search(r'gene_id "?([^";]+)"?', attr)
+            gname = re.search(r'gene_name "?([^";]+)"?', attr)
+            if tid and gid:
+                t = re.sub(r"\.[0-9]+$", "", tid.group(1))
+                g = re.sub(r"\.[0-9]+$", "", gid.group(1))
+                tx2gene[t] = g
+                if gname:
+                    gene2name[g] = gname.group(1)
+    log.debug(logid + "found " + str(len(tx2gene)) + " transcripts")
+    return tx2gene, gene2name
+
+
+def run_spit_cmd(subcmd, args_list):
+    logid = scriptname + ".run_spit_cmd: "
+    cmd = ["spit", subcmd] + [str(x) for x in args_list]
+    log.info(logid + " ".join(cmd))
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    log.debug(logid + "STDOUT: " + proc.stdout)
+    if proc.returncode != 0:
+        log.error(logid + "STDERR: " + proc.stderr)
+        raise RuntimeError("spit " + subcmd + " failed: " + proc.stderr)
+    else:
+        log.debug(logid + "STDERR: " + proc.stderr)
+    return
+
+
+def compute_lfc(ifs, ctrl_samples, case_samples):
+    eps = 1e-6
+    num = ifs.select_dtypes(include=[np.number])
+    a = num[case_samples].mean(axis=1)
+    b = num[ctrl_samples].mean(axis=1)
+    lfc = np.log2((a + eps) / (b + eps))
+    lfc[~np.isfinite(lfc)] = 0
+    return lfc
+
+
+def main(anname, gtf, outdir, cmp, combi, cores, spitopts):
+    logid = scriptname + ".main: "
+
+    pre_extra = []
+    dtu_extra = []
+    if spitopts and spitopts.strip():
+        if "||" in spitopts:
+            pre_part, dtu_part = spitopts.split("||", 1)
+            pre_extra = pre_part.split()
+            dtu_extra = dtu_part.split()
+        else:
+            dtu_extra = spitopts.split()
+
+    tx2gene, gene2name = parse_tx2gene(gtf)
+
+    sampleData_all = pd.read_csv(anname, sep="\t", compression="gzip", dtype=str)
+    sampleData_all["sample_id"] = sampleData_all["sample_id"].astype(str)
+
+    counts = {}
+    for _, row in sampleData_all.iterrows():
+        counts[row["sample_id"]] = read_quant(row["path"])
+    cts_all = pd.DataFrame(counts)
+    cts_all = cts_all.fillna(0)
+    cts_all = cts_all[cts_all.index.isin(tx2gene.keys())]
+    cts_all = cts_all[cts_all.sum(axis=1) > 0]
+    cts_all = cts_all.round().astype(int)
+    cts_all.index.name = "tx_id"
+
+    if combi == "none":
+        combi = ""
+
+    os.makedirs(os.path.join(outdir, "Tables"), exist_ok=True)
+    os.makedirs(os.path.join(outdir, "Figures"), exist_ok=True)
+    olddir = os.getcwd()
+    os.chdir(outdir)
+
+    session = {}
+
+    for contrast in cmp.split(","):
+        contrast_name = contrast.split(":")[0]
+        groups = contrast.split(":")[1].split("-vs-")
+        A = groups[0].split("+")
+        B = groups[1].split("+")
+        conds = A + B
+        log.info(logid + "contrast " + contrast_name + " A=" + str(A) + " B=" + str(B))
+
+        sub = sampleData_all[sampleData_all["condition"].isin(conds)]
+        case_samples = sub[sub["condition"].isin(A)]["sample_id"].tolist()
+        ctrl_samples = sub[sub["condition"].isin(B)]["sample_id"].tolist()
+        keep = case_samples + ctrl_samples
+        cts = cts_all[keep]
+        cts = cts[cts.sum(axis=1) > 0]
+
+        tmpdir = os.path.abspath("spit_tmp_" + contrast_name)
+        if os.path.exists(tmpdir):
+            shutil.rmtree(tmpdir)
+        os.makedirs(tmpdir)
+
+        cts_file = os.path.join(tmpdir, "tx_counts.txt")
+        tx2gene_file = os.path.join(tmpdir, "tx2gene.txt")
+        labels_file = os.path.join(tmpdir, "labels.txt")
+
+        cts.to_csv(cts_file, sep="\t")
+        t2g = pd.DataFrame(
+            {"tx_id": cts.index, "gene_id": [tx2gene[t] for t in cts.index]}
+        )
+        t2g.to_csv(tx2gene_file, sep="\t", index=False)
+
+        labels = pd.DataFrame(
+            {
+                "id": keep,
+                "condition": [1] * len(case_samples) + [0] * len(ctrl_samples),
+            }
+        )
+        batches = sub.set_index("sample_id").loc[keep, "batch"].tolist()
+        if len(set(batches)) > 1:
+            labels["batch"] = batches
+        labels.to_csv(labels_file, sep="\t", index=False)
+
+        shared = [
+            "-i", cts_file,
+            "-m", tx2gene_file,
+            "-l", labels_file,
+            "-O", tmpdir,
+            "--no_clusters",
+        ]
+        run_spit_cmd("preprocess", shared + pre_extra)
+        run_spit_cmd("dtu", shared + dtu_extra)
+
+        spitout = os.path.join(tmpdir, "SPIT_analysis", "spit_out.txt")
+        pvals = os.path.join(tmpdir, "SPIT_analysis", "all_p_values.txt")
+        ifsf = os.path.join(tmpdir, "SPIT_analysis", "dominance_selected_ifs.txt")
+        if not os.path.exists(ifsf):
+            ifsf = os.path.join(tmpdir, "SPIT_analysis", "filtered_ifs.txt")
+
+        spit_df = (
+            pd.read_csv(spitout, sep="\t")
+            if os.path.exists(spitout)
+            else pd.DataFrame(columns=["gene_id", "flag", "wasserstein_distance"])
+        )
+        pv_df = (
+            pd.read_csv(pvals, sep="\t", index_col=0)
+            if os.path.exists(pvals)
+            else pd.DataFrame(columns=["p_value"])
+        )
+        ifs_df = pd.read_csv(ifsf, sep="\t", index_col=0)
+
+        lfc = compute_lfc(ifs_df, ctrl_samples, case_samples)
+
+        tx_tab = pd.DataFrame(
+            {
+                "feature_id": ifs_df.index,
+                "pvalue": [
+                    pv_df["p_value"].get(t, np.nan) if "p_value" in pv_df else np.nan
+                    for t in ifs_df.index
+                ],
+                "lfc": lfc.values,
+                "gene_id": ifs_df["gene_id"].values,
+            }
+        )
+        tx_tab["Gene"] = [gene2name.get(g, g) for g in tx_tab["gene_id"]]
+        tx_tab = tx_tab.sort_values("pvalue", na_position="last")
+
+        gene_p = tx_tab.groupby("gene_id")["pvalue"].min()
+        maxidx = tx_tab.groupby("gene_id")["lfc"].apply(lambda s: s.abs().idxmax())
+        gene_lfc = tx_tab.loc[maxidx.values].set_index("gene_id")["lfc"]
+        gene_tab = pd.DataFrame({"gene_id": gene_p.index})
+        gene_tab["pvalue"] = gene_p.values
+        gene_tab["lfc"] = gene_lfc.reindex(gene_tab["gene_id"]).values
+        wd = spit_df.set_index("gene_id")["wasserstein_distance"] if len(spit_df) else pd.Series(dtype=float)
+        fl = spit_df.set_index("gene_id")["flag"] if len(spit_df) else pd.Series(dtype=str)
+        gene_tab["wasserstein_distance"] = gene_tab["gene_id"].map(wd).fillna("NA").values
+        gene_tab["flag"] = gene_tab["gene_id"].map(fl).fillna("").values
+        gene_tab["Gene"] = [gene2name.get(g, g) for g in gene_tab["gene_id"]]
+        gene_tab = gene_tab.sort_values("pvalue", na_position="last")
+
+        prefix = "_".join(["DTU", "SPIT", combi, contrast_name, "table"])
+        gene_tab.to_csv(
+            os.path.join("Tables", prefix + "_genes.tsv.gz"),
+            sep="\t", index=False, compression="gzip",
+        )
+        tx_tab.to_csv(
+            os.path.join("Tables", prefix + "_transcripts.tsv.gz"),
+            sep="\t", index=False, compression="gzip",
+        )
+        ifs_out = ifs_df.copy()
+        ifs_out.insert(0, "feature_id", ifs_out.index)
+        ifs_out.to_csv(
+            os.path.join("Tables", prefix + "_ifs.tsv.gz"),
+            sep="\t", index=False, compression="gzip",
+        )
+
+        figpre = "_".join(["DTU", "SPIT", combi, contrast_name, "figure"])
+        pv_clean = tx_tab["pvalue"].dropna()
+        plt.figure(figsize=(8, 6))
+        if len(pv_clean) > 0:
+            plt.hist(pv_clean, bins=20, color="steelblue", edgecolor="black")
+        plt.xlabel("p-value")
+        plt.ylabel("Frequency")
+        plt.title("SPIT transcript p-values " + contrast_name)
+        plt.tight_layout()
+        plt.savefig(os.path.join("Figures", figpre + "_PValues.png"), dpi=150)
+        plt.close()
+
+        plt.figure(figsize=(8, 6))
+        if len(spit_df) > 0:
+            top = spit_df.head(20)
+            plt.barh(
+                [str(x) for x in top["gene_id"]][::-1],
+                pd.to_numeric(top["wasserstein_distance"], errors="coerce").fillna(0).values[::-1],
+                color="darkorange",
+            )
+        plt.xlabel("Wasserstein distance")
+        plt.ylabel("Gene")
+        plt.title("SPIT top DTU genes " + contrast_name)
+        plt.tight_layout()
+        plt.savefig(os.path.join("Figures", figpre + "_Wasserstein.png"), dpi=150)
+        plt.close()
+
+        session[contrast_name] = {
+            "genes": gene_tab,
+            "transcripts": tx_tab,
+            "spit_out": spit_df,
+        }
+        shutil.rmtree(tmpdir)
+        log.info(logid + "done " + contrast_name)
+
+    with gzip.open("_".join(["DTU_SPIT", combi, "SESSION.gz"]), "wb") as fh:
+        pickle.dump(session, fh)
+
+    os.chdir(olddir)
+
+
+if __name__ == "__main__":
+    logid = scriptname + ".main: "
+    try:
+        args = sys.argv[1:]
+        anname = args[0]
+        gtf = args[1]
+        outdir = args[2]
+        cmp = args[3]
+        combi = args[4]
+        cores = int(args[5])
+        spitopts = args[6] if len(args) > 6 else ""
+
+        makelogdir("LOGS")
+        try:
+            log = setup_logger(
+                name=scriptname,
+                log_file="stderr",
+                logformat="%(asctime)s %(name)-12s %(levelname)-8s %(message)s",
+                datefmt="%m-%d %H:%M",
+                level="INFO",
+            )
+        except:
+            log = logging.getLogger(os.path.basename(inspect.stack()[-1].filename))
+
+        main(anname, gtf, outdir, cmp, combi, cores, spitopts)
+    except Exception:
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        tbe = tb.TracebackException(exc_type, exc_value, exc_tb)
+        try:
+            log.error(logid + "".join(tbe.format()))
+        except Exception:
+            print("".join(tbe.format()), file=sys.stderr)
+        sys.exit(1)
+
+#
+# SPIT.py ends here
diff --git a/workflows/spit_DTU.nf b/workflows/spit_DTU.nf
new file mode 100644
index 00000000..f02db235
--- /dev/null
+++ b/workflows/spit_DTU.nf
@@ -0,0 +1,270 @@
+BINS = get_always('BINS')
+DTUENV = get_always('DTUENV')
+DTUBIN = get_always('DTUBIN')
+DTUREF = get_always('DTUREF')
+DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+DTUANNO = get_always('DTUANNO')
+DTUDECOY = get_always('DTUDECOY')
+DTUIDX = get_always('DTUIDX')
+DTUUIDX = get_always('DTUUIDX')
+DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+IDXPARAMS = get_always('spit_DTU_params_INDEX') ?: ''
+COUNTPARAMS = get_always('spit_DTU_params_COUNT') ?: ''
+DTUPARAMS = get_always('spit_DTU_params_DTU') ?: ''
+DTUREPS = get_always('DTUREPS') ?: ''
+DTUCOMP = get_always('DTUCOMP') ?: ''
+DTUCOMPS = get_always('DTUCOMPS') ?: ''
+PVAL = get_always('DTUPVAL') ?: ''
+LFC = get_always('DTULFC') ?: ''
+PCOMBO = get_always('COMBO') ?: 'none'
+
+COUNTBIN = 'salmon'
+COUNTENV = 'salmon'
+
+//DTU PROCESSES
+
+process salmon_idx{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/spit_index.log"
+        else if (filename == "spit.idx")           "$DTUIDX"
+        else                                          "$DTUUIDX"
+    }
+
+    input:
+    path genome
+
+    output:
+     path "$DTUUIDXNAME", emit: idx
+    path "*.log", emit: idxlog
+    path "*.idx", emit: tmpidx
+
+    script:    
+    gen =  genome.getName()
+    if (DTUDECOY){
+        decoy = "-d "+"${DTUDECOY}" 
+    }else{
+        decoy = ''
+    }
+    """
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME spit.idx
+    """
+
+}
+
+process salmon_quant{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        r1 = rs[0]
+        r2 = rs[1]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+
+process prepare_dtu_annotation{
+    conda "$DTUENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_spit_annotation.log"
+    }
+
+    output:
+    path "*.gz", emit: anno
+    path "*.log", emit: log
+
+    script:     
+    ca = COMBO+"_ANNOTATION.gz"
+    ol = "create_DTU_table.log"
+    """
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    """
+}
+
+process run_spit{
+    conda "$DTUENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_spit.log"
+    }
+
+    input:
+    path counts
+    path anno
+    path ref
+
+    output:
+    path "*_table*", emit: tbls
+    path "*_figure*", emit: figs, optional:true
+    path "*SESSION.gz", emit: session
+    path "log", emit: log
+
+    script:    
+    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
+    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
+    comp = "${DTUCOMP}".split(':')[0]
+    dparams = "'${DTUPARAMS}'"
+
+    """
+    mkdir -p Figures Tables
+    python3 $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    """
+}
+
+process create_summary_snippet{
+    conda "$DTUENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+    }
+
+    input:
+    path de
+
+    output:
+    path "*.Rmd", emit: snps
+    path "log", emit: log
+
+    script:
+    inlist = de.toString()
+    // inlist = de.toList()  // { $workflow.projectDir += "$it.code,"  }
+    """
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    """
+}
+
+process collect_spit{
+    conda "$DTUENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    input:
+    path de
+
+    script:
+    """
+    echo "$de DONE"
+    """
+}
+
+workflow DTU{ 
+    take: collection
+
+    main:
+    
+    TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+        }
+
+    trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
+    annofile = Channel.fromPath(DTUANNO)
+    checkidx = file(DTUIDX)
+    
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(DTUUIDX)
+        if (PAIRED == 'paired'){
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
+        }        
+    }
+    else{
+        genomefile = Channel.fromPath(DTUREF)
+        salmon_idx(genomefile)
+        if (PAIRED == 'paired'){
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
+        }
+    }
+
+    prepare_dtu_annotation()
+    run_spit(salmon_quant.out.counts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    create_summary_snippet(run_spit.out.tbls.concat(run_spit.out.figs.concat(run_spit.out.session)).collect())
+    collect_spit(run_spit.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
+
+    emit:
+    tbls = run_spit.out.tbls
+    figs = run_spit.out.figs
+    snps = create_summary_snippet.out.snps
+}
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
new file mode 100644
index 00000000..32d9575c
--- /dev/null
+++ b/workflows/spit_DTU.smk
@@ -0,0 +1,168 @@
+logid = 'spit_DTU.smk '
+DTUBIN, DTUENV = env_bin_from_config(config,'DTU')
+log.debug(logid+"DTUENV: "+str(DTUENV))
+COUNTBIN, COUNTENV = ['salmon','salmon']#env_bin_from_config(SAMPLES, config,'COUNTING') ##PINNING subreads package to version 1.6.4 due to changes in 2.0.1 gene_id length cutoff that interfers
+
+comparison = comparable_as_string(config,'DTU')
+compstr = [i.split(":")[0] for i in comparison.split(",")]
+usededup = config.get('RUNDEDUP', False)
+
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = DTUENV
+unik = get_dict_hash(keydict)
+
+rule themall:
+    input:  session = expand("DTU/{combo}/DTU_SPIT_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
+            res_t   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_g   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_i   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_ifs.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            fig_PV  = expand("DTU/{combo}/Figures/DTU_SPIT_{scombo}_{comparison}_figure_PValues.png", combo=combo, comparison=compstr, scombo=scombo),
+            fig_W   = expand("DTU/{combo}/Figures/DTU_SPIT_{scombo}_{comparison}_figure_Wasserstein.png", combo=combo, comparison=compstr, scombo=scombo),
+            sig_t    = expand("DTU/{combo}/Tables/Sig_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dt   = expand("DTU/{combo}/Tables/SigDOWN_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ut   = expand("DTU/{combo}/Tables/SigUP_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_g    = expand("DTU/{combo}/Tables/Sig_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dg   = expand("DTU/{combo}/Tables/SigDOWN_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ug   = expand("DTU/{combo}/Tables/SigUP_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+
+rule salmon_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+
+if paired == 'paired':
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
+                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
+        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
+
+else:
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
+        shell:  "ln -s {params.filetolink} {output.r1}"
+
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+else:
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+
+rule create_annotation_table:
+    input:  dir  = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config)),
+    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
+    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
+            bins = BINS
+    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+
+rule run_DTU:
+    input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
+    output: session = rules.themall.input.session,
+            res_t   = rules.themall.input.res_t,
+            res_g   = rules.themall.input.res_g,
+            res_i   = rules.themall.input.res_i,
+            fig_PV  = rules.themall.input.fig_PV,
+            fig_W   = rules.themall.input.fig_W
+    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    conda:  ""+DTUENV+".yaml"
+    container: "oras://jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins   = str.join(os.sep,[BINS, DTUBIN]),
+            compare = comparison,
+            pcombo = scombo if scombo != '' else 'none',
+            outdir = 'DTU/'+combo,
+            ref = os.path.abspath(ANNOTATION),
+            dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
+    shell: "python3 {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
+
+rule filter_significant_spit:
+    input:  res_g = rules.themall.input.res_g,
+            res_t = rules.themall.input.res_t
+    output: sig_g   = rules.themall.input.sig_g,
+            sig_dg  = rules.themall.input.sig_dg,
+            sig_ug  = rules.themall.input.sig_ug,
+            sig_t   = rules.themall.input.sig_t,
+            sig_dt  = rules.themall.input.sig_dt,
+            sig_ut  = rules.themall.input.sig_ut
+    log:    "LOGS/DTU/filter_spitDTU.log"
+    conda:  ""+DTUENV+".yaml"
+    container: "oras://jfallmann/monsda:"+DTUENV+""
+    threads: 1
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+
+rule create_summary_snippet:
+    input:  rules.run_DTU.output.res_t,
+            rules.run_DTU.output.res_g,
+            rules.run_DTU.output.res_i,
+            rules.run_DTU.output.fig_PV,
+            rules.run_DTU.output.fig_W,
+            rules.themall.input.sig_g,
+            rules.themall.input.sig_dg,
+            rules.themall.input.sig_ug,
+            rules.themall.input.sig_t,
+            rules.themall.input.sig_dt,
+            rules.themall.input.sig_ut,
+            rules.themall.input.session
+    output: rules.themall.input.Rmd
+    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    conda:  ""+DTUENV+".yaml"
+    container: "oras://jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins = BINS,
+            abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
+    shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}"

From c1a9dd472138ec852de50067f424818f37e92e4e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 23 Jun 2026 21:50:34 +0200
Subject: [PATCH 02/80] CI/CD push with Opus 4.8

---
 .github/workflows/python-app.yaml | 106 +++++++++-
 .pre-commit-config.yaml           |  36 ++++
 CICD.md                           | 321 ++++++++++++++++++++++++++++++
 Makefile                          |  86 ++++++++
 4 files changed, 540 insertions(+), 9 deletions(-)
 create mode 100644 .pre-commit-config.yaml
 create mode 100644 CICD.md
 create mode 100644 Makefile

diff --git a/.github/workflows/python-app.yaml b/.github/workflows/python-app.yaml
index 3ba2edd8..b2cca401 100644
--- a/.github/workflows/python-app.yaml
+++ b/.github/workflows/python-app.yaml
@@ -1,6 +1,10 @@
 name: MONSDA CI
 
 on:
+  push:
+    branches: [main, develop]
+    tags:
+      - "v*"
   pull_request:
     types: [opened, synchronize, reopened, labeled, unlabeled]
   workflow_dispatch:
@@ -11,10 +15,35 @@ on:
         default: false
         type: boolean
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
+  lint:
+    name: Lint (flake8, isort)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+      - name: Install linting tools
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install flake8 isort
+      - name: Check import sorting with isort
+        run: isort --check-only --diff MONSDA/ tests/
+        continue-on-error: true
+      - name: Lint with flake8
+        run: flake8 MONSDA/ tests/ --count --statistics --show-source
+        continue-on-error: true
+
   tests:
     name: Unit tests (pytest)
     runs-on: ubuntu-latest
+    needs: lint
     defaults:
       run:
         shell: bash -el {0}
@@ -34,16 +63,54 @@ jobs:
           show-channel-urls: true
           use-only-tar-bz2: false
           auto-activate-base: false
-      - name: build and install MONSDA
+      - name: Install dependencies
         run: |
           cd ${{ github.workspace }}
           python -m pip install --upgrade pip
           python -m pip install -e .
-          python -m pip install pytest
-      - name: run unit tests
+          python -m pip install pytest pytest-cov
+      - name: Run unit tests with coverage
         run: |          
           cd ${{ github.workspace }}
-          pytest -q tests/test_Utils.py
+          pytest tests/test_Utils.py -v --cov=MONSDA --cov-report=xml --cov-report=html
+      - name: Upload coverage reports
+        uses: codecov/codecov-action@v4
+        if: always()
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: false
+          verbose: true
+
+  build:
+    name: Build package
+    runs-on: ubuntu-latest
+    needs: tests
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build wheel setuptools versioneer
+      - name: Build distribution
+        run: |
+          python -m build
+      - name: Check build artifacts
+        run: |
+          ls -lh dist/
+          python -m pip install twine
+          twine check dist/*
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+          retention-days: 7
 
   full-pipeline:
     name: Full pipeline integration test
@@ -71,23 +138,23 @@ jobs:
           show-channel-urls: true
           use-only-tar-bz2: false
           auto-activate-base: false
-      - name: build and install MONSDA
+      - name: Build and install MONSDA
         run: |
           cd ${{ github.workspace }}
           python -m pip install --upgrade pip
           python -m pip install -e .
-      - name: prepare integration test config
+      - name: Prepare integration test config
         run: |
           cd ${{ github.workspace }}
           VERSION=$(monsda --version 2>&1 | sed 's/MONSDA version //g')
           sed -i "s/\"VERSION\": \"FIXME\"/\"VERSION\": \"${VERSION}\"/g" tests/data/config_Test.json
-      - name: run full pipeline test
+      - name: Run full pipeline test
         run: |
           cd ${{ github.workspace }}/tests
           ln -fs data/* .
           mkdir -p CONDALIB
           monsda -j 6 -c config_Test.json --directory ${PWD} --use-conda --conda-prefix CONDALIB --save
-      - name: upload test logs on failure
+      - name: Upload test logs on failure
         if: failure()
         uses: actions/upload-artifact@v4
         with:
@@ -100,4 +167,25 @@ jobs:
             ${{ github.workspace }}/tests/QC
             ${{ github.workspace }}/tests/COUNTING
             ${{ github.workspace }}/tests/PEAKS
-            ${{ github.workspace }}/tests/TRACKS
\ No newline at end of file
+            ${{ github.workspace }}/tests/TRACKS
+
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/')
+    environment:
+      name: pypi
+      url: https://pypi.org/project/MONSDA
+    permissions:
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://upload.pypi.org/legacy/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..03f766a0
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,36 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+        args: ['--maxkb=1000']
+      - id: check-merge-conflict
+      - id: check-json
+      - id: mixed-line-ending
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        name: isort
+        language_version: python3.12
+
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+        name: flake8
+        language_version: python3.12
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.11.1
+    hooks:
+      - id: mypy
+        name: mypy
+        language_version: python3.12
+        additional_dependencies: ['types-PyYAML', 'types-setuptools']
+        args: ['--ignore-missing-imports', '--show-error-codes']
+        stages: [manual]
diff --git a/CICD.md b/CICD.md
new file mode 100644
index 00000000..92c998c3
--- /dev/null
+++ b/CICD.md
@@ -0,0 +1,321 @@
+# CI/CD Pipeline for MONSDA
+
+This document describes the Continuous Integration/Continuous Deployment (CI/CD) pipeline for MONSDA.
+
+## Overview
+
+The CI/CD pipeline is implemented using GitHub Actions and includes the following stages:
+
+1. **Linting** - Code quality checks with flake8 and isort
+2. **Testing** - Unit tests with pytest and coverage reporting
+3. **Building** - Package building and artifact verification
+4. **Integration Testing** - Full pipeline integration tests (optional)
+5. **Publishing** - Automatic deployment to PyPI on releases
+
+## Pipeline Stages
+
+### 1. Linting (Runs on all PRs and pushes)
+
+**Job:** `lint`
+
+Automatically checks code quality using:
+- **isort** - Validates import statement ordering
+- **flake8** - Checks PEP 8 compliance and code style
+
+**Configuration:**
+- Line length: 110 characters
+- Ignores: E203, E266, E501, W503
+- Continues on error (warnings don't block)
+
+Run locally:
+```bash
+make lint-check      # Check without fixing
+make lint            # Check and fix issues
+make format          # Format imports only
+```
+
+### 2. Unit Testing (Runs after linting)
+
+**Job:** `tests`
+
+Runs pytest test suite with coverage reporting:
+- Tests located in `tests/test_Utils.py`
+- Generates coverage reports (XML and HTML)
+- Uploads coverage to Codecov
+
+**Dependencies:**
+- Conda environment from `environment.yml`
+- Python 3.12.2
+- pytest and pytest-cov
+
+Run locally:
+```bash
+make test            # Run unit tests
+make test-cov        # Run with coverage report
+```
+
+### 3. Building (Runs after tests)
+
+**Job:** `build`
+
+Builds distribution packages:
+- Creates wheel and source distributions
+- Validates build artifacts with twine
+- Stores artifacts for 7 days
+
+**Tools:**
+- setuptools
+- wheel
+- versioneer (for version management)
+- twine (for package validation)
+
+Run locally:
+```bash
+make build           # Build distribution packages
+make clean-build     # Remove build artifacts
+```
+
+### 4. Full Pipeline Integration Test (Optional)
+
+**Job:** `full-pipeline`
+
+Runs comprehensive integration tests of the Snakemake/Nextflow pipeline functionality.
+
+**Trigger conditions:**
+- Manual workflow dispatch with `run_full_pipeline=true`
+- PR with `full-pipeline` label
+
+**Process:**
+1. Sets up Conda environment from `environment.yml`
+2. Installs MONSDA package
+3. Updates test configuration with current version
+4. Runs test workflow with sample data
+5. Uploads debug artifacts on failure
+
+Run locally:
+```bash
+RUN_INTEGRATION_TESTS=1 bash tests/cicd_test.sh
+```
+
+### 5. Publishing to PyPI (Runs on version tags)
+
+**Job:** `publish`
+
+Automatically publishes releases to PyPI when tags are pushed.
+
+**Trigger:** Tags matching pattern `v*` (e.g., `v1.0.0`)
+
+**Requirements:**
+- Build job must succeed
+- PyPI environment configured with trusted publishing
+- Token in GitHub secrets (automated via Trusted Publisher)
+
+**Manual deployment:**
+```bash
+make deploy          # Build and upload to PyPI
+```
+
+## Workflow Triggers
+
+The pipeline runs automatically on:
+
+- **Pull requests** - All PR types (opened, synchronize, reopened, labeled, unlabeled)
+- **Push to main/develop** - On code pushes to main and develop branches
+- **Version tags** - On tags matching `v*` (triggers PyPI publishing)
+- **Manual dispatch** - Triggered via GitHub Actions UI with options
+
+## Local Development Setup
+
+### Prerequisites
+
+- Python 3.12+
+- Conda/Mamba (for integration tests)
+- Git
+
+### Quick Setup
+
+```bash
+# Install development dependencies
+make install-dev
+
+# Set up pre-commit hooks
+make pre-commit
+```
+
+### Available Commands
+
+```bash
+# Code quality
+make lint            # Run isort and flake8 (auto-fix)
+make lint-check      # Check linting (don't fix)
+make format          # Format imports with isort
+
+# Testing
+make test            # Run unit tests
+make test-cov        # Run tests with coverage
+make test-integration # Run full pipeline tests
+
+# Building
+make build           # Build packages
+make clean           # Clean all artifacts
+make clean-pyc       # Remove Python cache files
+
+# Useful
+make help            # Show all commands
+```
+
+## Pre-commit Hooks
+
+Pre-commit hooks are configured to automatically check code before commits.
+
+### Setup
+
+```bash
+make pre-commit
+```
+
+### Hooks Included
+
+- Trailing whitespace removal
+- End-of-file fixer
+- YAML validation
+- Large file detection (>1MB)
+- Merge conflict detection
+- JSON validation
+- Line ending normalization
+- Import sorting (isort)
+- Code linting (flake8)
+- Type checking (mypy, optional)
+
+Run manually:
+```bash
+pre-commit run --all-files
+```
+
+## Configuration Files
+
+### GitHub Actions Workflow
+- **File:** `.github/workflows/python-app.yaml`
+- Defines all CI/CD pipeline stages
+- Configures job dependencies and triggers
+
+### Pre-commit Config
+- **File:** `.pre-commit-config.yaml`
+- Defines hooks run before commits
+- Includes linting and formatting tools
+
+### Makefile
+- **File:** `Makefile`
+- Provides convenient commands for local development
+- Mirrors CI/CD pipeline steps
+
+### Package Configuration
+- **File:** `pyproject.toml` - Modern Python project metadata
+- **File:** `setup.py` - Package installation script
+- **File:** `setup.cfg` - Tool configuration
+  - isort settings
+  - flake8 settings
+  - pytest configuration
+  - coverage settings
+
+### Environment
+- **File:** `environment.yml` - Conda environment for testing
+- Includes all runtime and development dependencies
+
+## Troubleshooting
+
+### Linting Failures
+
+If linting fails locally or in CI:
+
+```bash
+# Fix imports
+make format
+
+# Fix other issues manually (requires code changes)
+make lint-check  # See what needs fixing
+```
+
+### Test Failures
+
+```bash
+# Run tests with verbose output
+make test-cov
+
+# Check coverage gaps
+# Open htmlcov/index.html in browser
+```
+
+### Build Issues
+
+```bash
+# Clean previous builds
+make clean
+
+# Rebuild
+make build
+
+# Check for issues
+twine check dist/*
+```
+
+### Integration Test Failures
+
+```bash
+# Debug locally
+cd tests
+RUN_INTEGRATION_TESTS=1 bash cicd_test.sh
+
+# Check logs in tests/LOGS directory
+```
+
+## Version Management
+
+MONSDA uses **versioneer** for automatic version management:
+
+1. Version is defined in git tags
+2. Versioneer automatically derives version from git state
+3. Package version matches git tag (e.g., tag `v1.0.0` → package version `1.0.0`)
+
+**Release process:**
+1. Create release tag: `git tag v1.0.0`
+2. Push tag: `git push --tags`
+3. GitHub Actions automatically builds and publishes to PyPI
+
+## Best Practices
+
+1. **Always run linting before committing:**
+   ```bash
+   make pre-commit  # or rely on pre-commit hooks
+   ```
+
+2. **Run tests locally before pushing:**
+   ```bash
+   make test-cov
+   ```
+
+3. **Use meaningful commit messages** that reference issue numbers
+
+4. **Add tests for new features** to maintain coverage
+
+5. **Keep dependencies updated** by regularly running `pip install --upgrade`
+
+6. **Review CI logs** if builds fail to understand what needs fixing
+
+## Contact & Support
+
+For issues or questions about the CI/CD pipeline:
+- Check GitHub Actions logs for specific failures
+- Review this documentation
+- Open an issue on GitHub
+- Contact the maintainers
+
+## References
+
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- [pytest Documentation](https://docs.pytest.org/)
+- [flake8 Documentation](https://flake8.pycqa.org/)
+- [isort Documentation](https://pycqa.github.io/isort/)
+- [Pre-commit Framework](https://pre-commit.com/)
+- [Setuptools Documentation](https://setuptools.pypa.io/)
+- [Versioneer](https://github.com/python-versioneer/python-versioneer)
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..7f10bc85
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,86 @@
+.PHONY: help install install-dev lint lint-check format test test-cov build clean clean-build clean-pyc pre-commit deploy
+
+help:
+	@echo "MONSDA Development Commands:"
+	@echo ""
+	@echo "Setup:"
+	@echo "  make install          Install package in development mode"
+	@echo "  make install-dev      Install with development dependencies"
+	@echo ""
+	@echo "Code Quality:"
+	@echo "  make lint             Run isort and flake8 linters"
+	@echo "  make lint-check       Check linting without fixing (CI mode)"
+	@echo "  make format           Format code with isort"
+	@echo "  make pre-commit       Run pre-commit hooks"
+	@echo ""
+	@echo "Testing:"
+	@echo "  make test             Run unit tests"
+	@echo "  make test-cov         Run tests with coverage report"
+	@echo "  make test-integration Run integration tests (requires conda)"
+	@echo ""
+	@echo "Building:"
+	@echo "  make build            Build distribution packages"
+	@echo ""
+	@echo "Cleanup:"
+	@echo "  make clean            Remove all build/test artifacts"
+	@echo "  make clean-build      Remove build artifacts"
+	@echo "  make clean-pyc        Remove Python cache files"
+	@echo ""
+
+install:
+	python -m pip install --upgrade pip
+	python -m pip install -e .
+
+install-dev: install
+	python -m pip install pytest pytest-cov flake8 isort pre-commit build wheel twine
+
+lint:
+	isort MONSDA/ tests/
+	flake8 MONSDA/ tests/
+
+lint-check:
+	isort --check-only --diff MONSDA/ tests/
+	flake8 MONSDA/ tests/ --count --statistics --show-source
+
+format:
+	isort MONSDA/ tests/
+
+test:
+	pytest tests/test_Utils.py -v
+
+test-cov:
+	pytest tests/test_Utils.py -v --cov=MONSDA --cov-report=term-missing --cov-report=html
+
+test-integration:
+	cd tests && RUN_INTEGRATION_TESTS=1 bash cicd_test.sh
+
+build: clean
+	python -m pip install --upgrade pip
+	python -m pip install build wheel setuptools versioneer
+	python -m build
+	python -m pip install twine
+	twine check dist/*
+
+clean: clean-build clean-pyc
+
+clean-build:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info
+	rm -rf .eggs/
+	rm -rf *.egg
+	rm -rf .pytest_cache/
+	rm -rf .coverage
+	rm -rf htmlcov/
+
+clean-pyc:
+	find . -type f -name '*.py[cod]' -delete
+	find . -type d -name '__pycache__' -exec rm -rf {} + 2>/dev/null || true
+	find . -type d -name '*.egg-info' -exec rm -rf {} + 2>/dev/null || true
+
+pre-commit:
+	pre-commit install
+	pre-commit run --all-files
+
+deploy: build
+	python -m twine upload dist/*

From 54a007a4d80d963e3cf567b597dcef0cecc2d307 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 23 Jun 2026 22:14:24 +0200
Subject: [PATCH 03/80] version config automation

---
 .github/workflows/python-app.yaml |  8 ++-
 CICD.md                           | 33 +++++++++++
 Makefile                          | 14 ++++-
 scripts/update_config_versions.py | 95 +++++++++++++++++++++++++++++++
 4 files changed, 146 insertions(+), 4 deletions(-)
 create mode 100644 scripts/update_config_versions.py

diff --git a/.github/workflows/python-app.yaml b/.github/workflows/python-app.yaml
index b2cca401..f1f142ea 100644
--- a/.github/workflows/python-app.yaml
+++ b/.github/workflows/python-app.yaml
@@ -89,6 +89,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          fetch-depth: 0
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
@@ -97,6 +98,9 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           python -m pip install build wheel setuptools versioneer
+      - name: Sync config versions
+        run: |
+          python scripts/update_config_versions.py configs/*.json tests/data/config_*.json
       - name: Build distribution
         run: |
           python -m build
@@ -126,6 +130,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          fetch-depth: 0
       - uses: conda-incubator/setup-miniconda@v3
         with:
           miniconda-version: "latest"
@@ -146,8 +151,7 @@ jobs:
       - name: Prepare integration test config
         run: |
           cd ${{ github.workspace }}
-          VERSION=$(monsda --version 2>&1 | sed 's/MONSDA version //g')
-          sed -i "s/\"VERSION\": \"FIXME\"/\"VERSION\": \"${VERSION}\"/g" tests/data/config_Test.json
+          python scripts/update_config_versions.py tests/data/config_Test.json
       - name: Run full pipeline test
         run: |
           cd ${{ github.workspace }}/tests
diff --git a/CICD.md b/CICD.md
index 92c998c3..1c3efdb7 100644
--- a/CICD.md
+++ b/CICD.md
@@ -160,6 +160,10 @@ make build           # Build packages
 make clean           # Clean all artifacts
 make clean-pyc       # Remove Python cache files
 
+# Versioning
+make sync-config-versions   # Stamp config VERSION fields with the git-tag version
+make check-config-versions  # Verify config VERSION fields are in sync
+
 # Useful
 make help            # Show all commands
 ```
@@ -282,6 +286,35 @@ MONSDA uses **versioneer** for automatic version management:
 2. Push tag: `git push --tags`
 3. GitHub Actions automatically builds and publishes to PyPI
 
+### Config Version Synchronization
+
+The `VERSION` field in the config files under `configs/` and `tests/data/`
+is kept in sync with the versioneer-derived version automatically, so that
+`monsda`'s runtime version check (`monsda_check_version`) always passes.
+
+This is handled by `scripts/update_config_versions.py`, which mirrors the same
+version source used at runtime (`MONSDA.__version__`, falling back to
+`python setup.py --version`). The script is comment-safe (config files contain
+`#` comments and are not strict JSON) and only rewrites empty, `FIXME`, or
+version-like `VERSION` values, leaving documentation strings untouched.
+
+It runs automatically in CI:
+- In the **build** job, before `python -m build`, so the published package ships
+  templates matching the release version.
+- In the **full-pipeline** job, before the integration test, replacing the old
+  `sed`-based patching.
+
+Both jobs use `fetch-depth: 0` on checkout so versioneer can resolve git tags.
+
+Run locally:
+```bash
+make sync-config-versions    # Stamp config VERSION fields with the git-tag version
+make check-config-versions   # Verify config VERSION fields are in sync (CI mode)
+
+# Or invoke the script directly with an explicit version
+python scripts/update_config_versions.py --version 1.5.0 configs/*.json
+```
+
 ## Best Practices
 
 1. **Always run linting before committing:**
diff --git a/Makefile b/Makefile
index 7f10bc85..869d272d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: help install install-dev lint lint-check format test test-cov build clean clean-build clean-pyc pre-commit deploy
+.PHONY: help install install-dev lint lint-check format test test-cov build clean clean-build clean-pyc pre-commit deploy sync-config-versions check-config-versions
 
 help:
 	@echo "MONSDA Development Commands:"
@@ -18,6 +18,10 @@ help:
 	@echo "  make test-cov         Run tests with coverage report"
 	@echo "  make test-integration Run integration tests (requires conda)"
 	@echo ""
+	@echo "Versioning:"
+	@echo "  make sync-config-versions   Stamp config VERSION fields with the git-tag version"
+	@echo "  make check-config-versions  Verify config VERSION fields match (CI mode)"
+	@echo ""
 	@echo "Building:"
 	@echo "  make build            Build distribution packages"
 	@echo ""
@@ -54,7 +58,13 @@ test-cov:
 test-integration:
 	cd tests && RUN_INTEGRATION_TESTS=1 bash cicd_test.sh
 
-build: clean
+sync-config-versions:
+	python scripts/update_config_versions.py configs/*.json tests/data/config_*.json
+
+check-config-versions:
+	python scripts/update_config_versions.py --check configs/*.json tests/data/config_*.json
+
+build: clean sync-config-versions
 	python -m pip install --upgrade pip
 	python -m pip install build wheel setuptools versioneer
 	python -m build
diff --git a/scripts/update_config_versions.py b/scripts/update_config_versions.py
new file mode 100644
index 00000000..d5f17ea8
--- /dev/null
+++ b/scripts/update_config_versions.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+"""Synchronize the "VERSION" field in MONSDA config files with the
+versioneer-derived package version (single source of truth).
+
+This mirrors what versioneer does for the Python package: instead of hard
+coding a version, the value is derived from the current git tag/state so the
+config files always fit the release they ship with.
+
+MONSDA config files may contain ``#`` comments (i.e. they are not strict
+JSON), therefore replacement is line/regex based and preserves comments,
+indentation and trailing commas. Only values that are empty, ``FIXME`` or
+version-like are replaced, so documentation strings such as
+``"VERSION": "Version of MONSDA to use, ..."`` are left untouched.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+import re
+
+VERSION_LINE = re.compile(
+    r'^(?P<pre>\s*"VERSION"\s*:\s*")(?P<val>[^"]*)(?P<post>".*)$', re.MULTILINE
+)
+VERSION_LIKE = re.compile(r"^v?\d+(\.\d+)*([._\-+].*)?$")
+
+
+def get_version():
+    """Return the versioneer-derived version (same value used at runtime)."""
+    try:
+        from MONSDA import __version__
+
+        return __version__
+    except Exception:
+        root = Path(__file__).resolve().parent.parent
+        out = subprocess.check_output(
+            [sys.executable, "setup.py", "--version"], cwd=root
+        )
+        return out.decode().strip().splitlines()[-1].strip()
+
+
+def is_replaceable(val):
+    v = val.strip()
+    return v == "" or v.upper() == "FIXME" or bool(VERSION_LIKE.match(v))
+
+
+def update_text(text, version):
+    changed = {"n": 0}
+
+    def repl(m):
+        if is_replaceable(m.group("val")) and m.group("val") != version:
+            changed["n"] += 1
+            return m.group("pre") + version + m.group("post")
+        return m.group(0)
+
+    return VERSION_LINE.sub(repl, text), changed["n"]
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("files", nargs="+", help="Config files to update")
+    parser.add_argument(
+        "--version",
+        default=None,
+        help="Version to write (default: versioneer-derived package version)",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Do not modify files; exit non-zero if any file is out of sync",
+    )
+    args = parser.parse_args(argv)
+
+    version = args.version or get_version()
+    rc = 0
+    for f in args.files:
+        path = Path(f)
+        if not path.is_file():
+            print(f"skip (not found): {f}", file=sys.stderr)
+            continue
+        text = path.read_text()
+        new, n = update_text(text, version)
+        if n == 0:
+            continue
+        if args.check:
+            print(f"out of sync: {f} (expected VERSION={version})", file=sys.stderr)
+            rc = 1
+        else:
+            path.write_text(new)
+            print(f"updated {f}: VERSION -> {version} ({n} field(s))")
+    return rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From a616bb0e23ff108f121afd71edb2c87caf27c61f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 2 Jul 2026 17:13:40 +0200
Subject: [PATCH 04/80] added gene coordinates to all DE output to make it
 easier to catch CNV like patterns

---
 scripts/Analysis/DAS/EDGER.R       | 20 +++++++++-----
 scripts/Analysis/DE/DESEQ2.R       | 30 ++++++++++++---------
 scripts/Analysis/DE/EDGER.R        | 23 +++++++++++-----
 scripts/Analysis/DE/EDGER_no_rep.R |  9 +++++++
 scripts/Analysis/DEU/DEXSEQ.R      |  1 +
 scripts/Analysis/DEU/EDGER.R       |  3 +++
 scripts/Analysis/DTU/DEXSEQ.R      |  1 +
 scripts/Analysis/DTU/DRIMSEQ.R     |  4 +++
 scripts/Analysis/DTU/SPIT.py       | 11 ++++++--
 scripts/lib/_lib.R                 | 43 ++++++++++++++++++++++++++++++
 10 files changed, 117 insertions(+), 28 deletions(-)

diff --git a/scripts/Analysis/DAS/EDGER.R b/scripts/Analysis/DAS/EDGER.R
index f38a7c21..c8f55e4a 100755
--- a/scripts/Analysis/DAS/EDGER.R
+++ b/scripts/Analysis/DAS/EDGER.R
@@ -98,6 +98,7 @@ tmm.genes <- tmm
 tmm.genes$Gene <- lapply(tmm.genes$ID, function(x) {
     get_gene_name(x, gtf_gene)
 })
+tmm.genes <- add_gene_coordinates(tmm.genes, tmm.genes$ID, gtf_gene, after = "ID")
 tmm.genes <- as.data.frame(apply(tmm.genes, 2, as.character))
 write.table(as.data.frame(tmm.genes), gzfile(paste("Tables/DAS", "EDGER", combi, "DataSet", "table", "AllConditionsNormalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -203,6 +204,7 @@ for (compare in comparisons[[1]]) {
     tmm.genes$Gene <- lapply(tmm.genes$ID, function(x) {
         get_exon_name(x, gtf.df)
     })
+    tmm.genes <- add_gene_coordinates(tmm.genes, vapply(strsplit(as.character(tmm.genes$ID), split = ":"), `[`, character(1), 1), gtf_gene, after = "ID")
     tmm.genes <- as.data.frame(apply(tmm.genes, 2, as.character))
     write.table(as.data.frame(tmm.genes), gzfile(paste("Tables/DAS", "EDGER", combi, contrast_name, "DataSet", "table", "Normalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -252,29 +254,35 @@ for (compare in comparisons[[1]]) {
         comparison_objs <- append(comparison_objs, sp)
 
         tops <- topSpliceDGE(sp, test = "gene", n = length(fit$counts))
-        tops$Gene <- lapply(strsplit(rownames(tops), split = ":")[[1]][1], function(x) {
+        gene_ids <- vapply(strsplit(rownames(tops), split = ":"), `[`, character(1), 1)
+        tops$Gene <- vapply(gene_ids, function(x) {
             get_gene_name(x, gtf.df)
-        })
+        }, character(1))
         tops$Gene_ID <- rownames(tops)
         tops <- tops[, c(7, 6, 3, 4, 5, 2)]
+        tops <- add_gene_coordinates(tops, gene_ids, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(as.data.frame(tops), gzfile(paste("Tables/DAS", "EDGER", combi, contrast_name, "table", "resultsGeneTest.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topSpliceDGE(sp, test = "simes", n = length(fit$counts))
-        tops$Gene <- lapply(strsplit(rownames(tops), split = ":")[[1]][1], function(x) {
+        gene_ids <- vapply(strsplit(rownames(tops), split = ":"), `[`, character(1), 1)
+        tops$Gene <- vapply(gene_ids, function(x) {
             get_gene_name(x, gtf_gene)
-        })
+        }, character(1))
         tops$Gene_ID <- rownames(tops)
         tops <- tops[, c(6, 5, 2, 3, 4)]
+        tops <- add_gene_coordinates(tops, gene_ids, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(as.data.frame(tops), gzfile(paste("Tables/DAS", "EDGER", combi, contrast_name, "table", "resultsSimesTest.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topSpliceDGE(sp, test = "exon", n = length(fit$counts))
-        tops$Gene <- lapply(strsplit(rownames(tops), split = ":")[[1]][1], function(x) {
+        gene_ids <- vapply(strsplit(rownames(tops), split = ":"), `[`, character(1), 1)
+        tops$Gene <- vapply(gene_ids, function(x) {
             get_gene_name(x, gtf_gene)
-        })
+        }, character(1))
         tops$Gene_ID <- rownames(tops)
         tops <- tops[, c(8, 7, 4, 5, 6, 2, 3)]
+        tops <- add_gene_coordinates(tops, gene_ids, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(as.data.frame(tops), gzfile(paste("Tables/DAS", "EDGER", combi, contrast_name, "table", "resultsDiffSpliceExonTest.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 8d15b48c..aa3e59db 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -76,8 +76,8 @@ cpm_matrix <- calc_cpm(countData_all)
 tpm_matrix <- calc_tpm(countData_all, gtf_gene)
 
 # Write out CPM and TPM tables
-write.table(cpm_matrix, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "cpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-write.table(tpm_matrix, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "tpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+write.table(add_gene_coordinates(cpm_matrix, rownames(cpm_matrix), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "cpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+write.table(add_gene_coordinates(tpm_matrix, rownames(tpm_matrix), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "tpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
 
 # Normalize by spike in if available
 if (spike != "") {
@@ -91,17 +91,17 @@ if (spike != "") {
     counts_norm <- as.data.frame(normCounts(counts_norm))
     countData_clean <- countData_all %>% subset(!row.names(countData_all) %in% ctrlgenes) # removing spike-ins for standard analysis
     counts_norm_clean <- counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes) # removing spike-ins for standard analysis
-     write.table(counts_norm, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(counts_norm_clean, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_norm_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(countData_clean, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+     write.table(add_gene_coordinates(counts_norm, rownames(counts_norm), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(counts_norm_clean, rownames(counts_norm_clean), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_norm_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(countData_clean, rownames(countData_clean), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
     write.table(sampleData_norm, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "sampleData_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
     # Calculate CPM and TPM
     cpm_norm_matrix <- calc_cpm(counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes))
     tpm_norm_matrix <- calc_tpm(counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes), gtf_gene)
 
     # Write out CPM and TPM tables
-    write.table(cpm_norm_matrix, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "cpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(tpm_norm_matrix, gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "tpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(cpm_norm_matrix, rownames(cpm_norm_matrix), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "cpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(tpm_norm_matrix, rownames(tpm_norm_matrix), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "tpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
 
 }
 #### Now plot and print over-all comparisons
@@ -129,8 +129,8 @@ print(DESeq2::plotPCA(vsd, intgroup = c("condition")) + geom_text_repel(aes(labe
 dev.off()
 
 # We also write the normalized counts to file
-write.table(as.data.frame(assay(rld)), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "rld.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
-write.table(as.data.frame(assay(vsd)), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "vsd.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+write.table(add_gene_coordinates(as.data.frame(assay(rld)), rownames(assay(rld)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "rld.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+write.table(add_gene_coordinates(as.data.frame(assay(vsd)), rownames(assay(vsd)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "vsd.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
 
 # Here we choose blind so that the initial conditions setting does not influence the outcome, ie we want to see if the conditions cluster based purely on the individual datasets, in an unbiased way. According to the documentation, the rlogTransformation method that converts counts to log2 values is apparently better than the old varienceStabilisation method when the data size factors vary by large amounts.
 
@@ -261,8 +261,8 @@ for (contrast in comparison[[1]]) {
         dev.off()
 
         # We also write the normalized counts to file
-        write.table(as.data.frame(assay(rld_norm)), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "rld_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
-        write.table(as.data.frame(assay(vsd_norm)), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "vsd_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+        write.table(add_gene_coordinates(as.data.frame(assay(rld_norm)), rownames(assay(rld_norm)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "rld_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+        write.table(add_gene_coordinates(as.data.frame(assay(vsd_norm)), rownames(assay(vsd_norm)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "vsd_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
     }
 
     # Create DESeqDataSet
@@ -294,8 +294,8 @@ for (contrast in comparison[[1]]) {
     dev.off()
 
     # We also write the normalized counts to file
-    write.table(as.data.frame(assay(rld)), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "rld.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
-    write.table(as.data.frame(assay(vsd)), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "vsd.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+    write.table(add_gene_coordinates(as.data.frame(assay(rld)), rownames(assay(rld)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "rld.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
+    write.table(add_gene_coordinates(as.data.frame(assay(vsd)), rownames(assay(vsd)), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "vsd.tsv.gz", sep = "_")), sep = "\t", col.names = NA)
 
     tryCatch({
         # initialize empty objects
@@ -317,6 +317,7 @@ for (contrast in comparison[[1]]) {
         }))
         resOrdered$Gene_ID <- rownames(resOrdered)
         resOrdered <- resOrdered[, c(7, 6, 1, 2, 3, 4, 5)]
+        resOrdered <- add_gene_coordinates(resOrdered, resOrdered$Gene_ID, gtf_gene, after = "Gene_ID")
 
         # plotVolcano
         pdf(
@@ -357,6 +358,7 @@ for (contrast in comparison[[1]]) {
         })
         res$Gene_ID <- rownames(res)
         res <- res[, c(8, 7, 1, 2, 3, 5, 6)]
+        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
         res <- as.data.frame(apply(res, 2, as.character))
 
         write.table(as.data.frame(res), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "results_noshrink.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
@@ -388,6 +390,7 @@ for (contrast in comparison[[1]]) {
             }))
             resOrdered$Gene_ID <- rownames(resOrdered)
             resOrdered <- resOrdered[, c(7, 6, 1, 2, 3, 4, 5)]
+            resOrdered <- add_gene_coordinates(resOrdered, resOrdered$Gene_ID, gtf_gene, after = "Gene_ID")
 
             # plot Volcano
             pdf(
@@ -428,6 +431,7 @@ for (contrast in comparison[[1]]) {
             })
             res$Gene_ID <- rownames(res)
             res <- res[, c(7, 6, 1, 2, 3, 4, 5)]
+            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
             res <- as.data.frame(apply(res, 2, as.character))
 
             write.table(as.data.frame(res), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "results_norm_noshrink.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 6ed8bcfb..d32cc218 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -74,8 +74,8 @@ cpm_matrix <- calc_cpm(countData_all)
 tpm_matrix <- calc_tpm(countData_all, gtf_gene)
 
 ## Write out CPM and TPM tables
-write.table(cpm_matrix, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "cpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-write.table(tpm_matrix, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "tpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+write.table(add_gene_coordinates(cpm_matrix, rownames(cpm_matrix), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "cpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+write.table(add_gene_coordinates(tpm_matrix, rownames(tpm_matrix), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "tpm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
 
 ## Normalize by spike in if available
 if (spike != "") {
@@ -89,17 +89,17 @@ if (spike != "") {
     counts_norm <- as.data.frame(normCounts(counts_norm))
     countData_clean <- countData_all %>% subset(!row.names(countData_all) %in% ctrlgenes) # removing spike-ins for standard analysis
     counts_norm_clean <- counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes) # removing spike-ins for standard analysis
-    write.table(counts_norm, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(counts_norm_clean, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_norm_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(countData_clean, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(counts_norm, rownames(counts_norm), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(counts_norm_clean, rownames(counts_norm_clean), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_norm_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(countData_clean, rownames(countData_clean), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_clean.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
     write.table(sampleData_norm, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "sampleData_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
     # Calculate CPM and TPM
     cpm_norm_matrix <- calc_cpm(counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes))
     tpm_norm_matrix <- calc_tpm(counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes), gtf_gene)
 
     # Write out CPM and TPM tables
-    write.table(cpm_norm_matrix, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "cpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
-    write.table(tpm_norm_matrix, gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "tpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(cpm_norm_matrix, rownames(cpm_norm_matrix), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "cpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(add_gene_coordinates(tpm_norm_matrix, rownames(tpm_norm_matrix), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "tpm_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
 }
 
 ## Create design-table considering different types (paired, unpaired) and batches
@@ -126,6 +126,7 @@ colnames(tmm) <- t(dge$samples$samples)
 tmm$ID <- dge$genes$genes
 tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
 write.table(as.data.frame(tmm), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "AllConditionsNormalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
 ## create file MDS-plot with and without summarized replicates
@@ -231,6 +232,7 @@ for (contrast in comparison[[1]]) {
         tmm_norm$ID <- dge_norm$genes$genes
         tmm_norm <- tmm_norm[c(ncol(tmm_norm), 1:ncol(tmm_norm) - 1)]
 
+        tmm_norm <- add_gene_coordinates(tmm_norm, tmm_norm$ID, gtf_gene, after = "ID")
         write.table(as.data.frame(tmm_norm), gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "Normalized_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         ## create file MDS-plot with and without summarized replicates
@@ -278,6 +280,7 @@ for (contrast in comparison[[1]]) {
     tmm$ID <- dge$genes$genes
     tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+    tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
     write.table(as.data.frame(tmm), gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "Normalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
     ## create file MDS-plot with and without summarized replicates
@@ -331,6 +334,7 @@ for (contrast in comparison[[1]]) {
         qlf$table$Gene_ID <- rownames(qlf$table)
         res <- qlf$table[, c(6, 5, 2, 1, 3, 4)]
         res$FDR <- p.adjust(res$PValue, method = "BH")
+        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
 
         # plotVolcano
         pdf(
@@ -366,11 +370,13 @@ for (contrast in comparison[[1]]) {
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
         tops <- tops$table[, c(7, 6, 3, 2, 4, 5, 8)]
+        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
         tops <- tops$table[, c(7, 6, 3, 2, 4, 5, 8)]
+        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -412,6 +418,7 @@ for (contrast in comparison[[1]]) {
             qlf$table$Gene_ID <- rownames(qlf$table)
             res <- qlf$table[, c(6, 5, 1, 2, 3, 4)]
             res$FDR <- p.adjust(res$PValue, method = "BH")
+            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
 
             # plotVolcano
             pdf(
@@ -447,11 +454,13 @@ for (contrast in comparison[[1]]) {
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
             tops <- tops$table[, c(7, 6, 4, 2, 3, 5, 8)]
+            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
             tops <- tops$table[, c(7, 6, 4, 2, 3, 5, 8)]
+            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index 7d63d483..ea27bbd9 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -101,6 +101,7 @@ colnames(tmm) <- t(dge$samples$samples)
 tmm$ID <- dge$genes$genes
 tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
 write.table(as.data.frame(tmm), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "AllConditionsNormalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
 ## create dummy file MDS-plot with and without summarized replicates
@@ -194,6 +195,7 @@ for (contrast in comparison[[1]]) {
         tmm_norm$ID <- dge_norm$genes$genes
         tmm_norm <- tmm_norm[c(ncol(tmm_norm), 1:ncol(tmm_norm) - 1)]
 
+        tmm_norm <- add_gene_coordinates(tmm_norm, tmm_norm$ID, gtf_gene, after = "ID")
         write.table(as.data.frame(tmm_norm), gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "DataSet", "table", "Normalized_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         ## create dummy file MDS-plot with and without summarized replicates
@@ -232,6 +234,7 @@ for (contrast in comparison[[1]]) {
     tmm$ID <- dge$genes$genes
     tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+    tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
     write.table(as.data.frame(tmm), gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "DataSet", "table", "Normalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
     ## create dummy file MDS-plot with and without summarized replicates
@@ -283,6 +286,7 @@ for (contrast in comparison[[1]]) {
         qlf$table$Gene_ID <- rownames(qlf$table)
         res <- qlf$table[, c(5, 4, 2, 1, 3)]
         res$FDR <- p.adjust(res$PValue, method = "BH")
+        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
 
         # plotVolcano
         pdf(
@@ -318,11 +322,13 @@ for (contrast in comparison[[1]]) {
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
         tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
         tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -366,6 +372,7 @@ for (contrast in comparison[[1]]) {
             qlf$table$Gene_ID <- rownames(qlf$table)
             res <- qlf$table[, c(5, 4, 2, 1, 3)]
             res$FDR <- p.adjust(res$PValue, method = "BH")
+            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
 
             # plotVolcano
             pdf(
@@ -401,11 +408,13 @@ for (contrast in comparison[[1]]) {
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
             tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
             tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/Analysis/DEU/DEXSEQ.R b/scripts/Analysis/DEU/DEXSEQ.R
index c2fa38a6..b66c1c8d 100755
--- a/scripts/Analysis/DEU/DEXSEQ.R
+++ b/scripts/Analysis/DEU/DEXSEQ.R
@@ -179,6 +179,7 @@ for (contrast in comparisons[[1]]) {
 
         toprint <- as.data.frame(dxr1)
         toprint$transcripts <- vapply(toprint$transcripts, paste, collapse = ", ", character(1L))
+        toprint <- add_gene_coordinates(toprint, toprint$groupID, gtf.df, after = "groupID")
         write.table(toprint, gzfile(paste("Tables/DEU", "DEXSEQ", combi, contrast_name, "table", "results.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
 
 
diff --git a/scripts/Analysis/DEU/EDGER.R b/scripts/Analysis/DEU/EDGER.R
index 763a4afa..6511bafa 100755
--- a/scripts/Analysis/DEU/EDGER.R
+++ b/scripts/Analysis/DEU/EDGER.R
@@ -97,6 +97,7 @@ colnames(tmm) <- t(dge$samples$samples)
 tmm$ID <- dge$genes$genes
 tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
 write.table(as.data.frame(tmm), gzfile(paste("Tables/DEU", "EDGER", combi, "DataSet", "table", "AllConditionsNormalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
 ## create file MDS-plot with and without summarized replicates
@@ -198,6 +199,7 @@ for (compare in comparisons[[1]]) {
     tmm$ID <- dge$genes$genes
     tmm <- tmm[c(ncol(tmm), 1:ncol(tmm) - 1)]
 
+    tmm <- add_gene_coordinates(tmm, tmm$ID, gtf_gene, after = "ID")
     write.table(as.data.frame(tmm), gzfile(paste("Tables/DEU", "EDGER", combi, contrast_name, "DataSet", "table", "Normalized.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
     ## create file MDS-plot with and without summarized replicates
@@ -253,6 +255,7 @@ for (compare in comparisons[[1]]) {
         qlf$table$Gene_ID <- qlf$genes$genes
         qlf$table$ExonPos <- qlf$genes$exons
         res <- qlf$table[, c(6, 5, 7, 1, 2, 3, 4)]
+        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
         res <- as.data.frame(apply(res, 2, as.character))
 
         # create results table
diff --git a/scripts/Analysis/DTU/DEXSEQ.R b/scripts/Analysis/DTU/DEXSEQ.R
index 5808698f..bd3a865e 100755
--- a/scripts/Analysis/DTU/DEXSEQ.R
+++ b/scripts/Analysis/DTU/DEXSEQ.R
@@ -171,6 +171,7 @@ for (contrast in comparisons[[1]]) {
     toprint$transcripts <- vapply(toprint$featureID, paste, collapse = ", ", character(1L))
     toprint$genes <- vapply(toprint$Gene, paste, collapse = ", ", character(1L))
     toprint <- subset(toprint, select = -c(Gene, featureID))
+    toprint <- add_gene_coordinates(toprint, toprint$groupID, gtf.df, after = "groupID")
 
     write.table(toprint, gzfile(paste("Tables/DTU", "DEXSEQ", combi, contrast_name, "table", "results.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/Analysis/DTU/DRIMSEQ.R b/scripts/Analysis/DTU/DRIMSEQ.R
index aab0fc31..c3a41d65 100755
--- a/scripts/Analysis/DTU/DRIMSEQ.R
+++ b/scripts/Analysis/DTU/DRIMSEQ.R
@@ -318,6 +318,9 @@ for (contrast in comparisons[[1]]) {
         get_gene_name(x, gtf.df)
     })
 
+    res <- add_gene_coordinates(res, res$gene_id, gtf.df, after = "gene_id")
+    res.txp <- add_gene_coordinates(res.txp, res.txp$gene_id, gtf.df, after = "gene_id")
+
     res <- res[order(res$adj_pvalue), ]
     res.txp <- res.txp[order(res$adj_pvalue), ]
     proportions <- proportions[order(proportions$lfc), ]
@@ -326,6 +329,7 @@ for (contrast in comparisons[[1]]) {
     for (c in 3:(length(colnames(proportions.print)) - 4)) {
         colnames(proportions.print)[c] <- sampleData$original_sample_id[sampleData$sample_id == colnames(proportions.print)[c]]
     }
+    proportions.print <- add_gene_coordinates(proportions.print, proportions.print$gene_id, gtf.df, after = "gene_id")
     res.print <- as.data.frame(apply(res, 2, as.character))
     res.txp.print <- as.data.frame(apply(res.txp, 2, as.character))
 
diff --git a/scripts/Analysis/DTU/SPIT.py b/scripts/Analysis/DTU/SPIT.py
index 8a354203..4c7770f3 100644
--- a/scripts/Analysis/DTU/SPIT.py
+++ b/scripts/Analysis/DTU/SPIT.py
@@ -53,6 +53,7 @@ def parse_tx2gene(gtf):
     logid = scriptname + ".parse_tx2gene: "
     tx2gene = {}
     gene2name = {}
+    gene2coord = {}
     opn = gzip.open if str(gtf).endswith(".gz") else open
     with opn(gtf, "rt") as fh:
         for line in fh:
@@ -65,6 +66,9 @@ def parse_tx2gene(gtf):
             tid = re.search(r'transcript_id "?([^";]+)"?', attr)
             gid = re.search(r'gene_id "?([^";]+)"?', attr)
             gname = re.search(r'gene_name "?([^";]+)"?', attr)
+            if cols[2] == "gene" and gid:
+                g = re.sub(r"\.[0-9]+$", "", gid.group(1))
+                gene2coord[g] = cols[0] + ":" + cols[3] + ":" + cols[4] + ":" + cols[6]
             if tid and gid:
                 t = re.sub(r"\.[0-9]+$", "", tid.group(1))
                 g = re.sub(r"\.[0-9]+$", "", gid.group(1))
@@ -72,7 +76,7 @@ def parse_tx2gene(gtf):
                 if gname:
                     gene2name[g] = gname.group(1)
     log.debug(logid + "found " + str(len(tx2gene)) + " transcripts")
-    return tx2gene, gene2name
+    return tx2gene, gene2name, gene2coord
 
 
 def run_spit_cmd(subcmd, args_list):
@@ -112,7 +116,7 @@ def main(anname, gtf, outdir, cmp, combi, cores, spitopts):
         else:
             dtu_extra = spitopts.split()
 
-    tx2gene, gene2name = parse_tx2gene(gtf)
+    tx2gene, gene2name, gene2coord = parse_tx2gene(gtf)
 
     sampleData_all = pd.read_csv(anname, sep="\t", compression="gzip", dtype=str)
     sampleData_all["sample_id"] = sampleData_all["sample_id"].astype(str)
@@ -236,6 +240,8 @@ def main(anname, gtf, outdir, cmp, combi, cores, spitopts):
         gene_tab = gene_tab.sort_values("pvalue", na_position="last")
 
         prefix = "_".join(["DTU", "SPIT", combi, contrast_name, "table"])
+        gene_tab.insert(gene_tab.columns.get_loc("gene_id") + 1, "Coordinates", [gene2coord.get(g, "NA") for g in gene_tab["gene_id"]])
+        tx_tab.insert(tx_tab.columns.get_loc("gene_id") + 1, "Coordinates", [gene2coord.get(g, "NA") for g in tx_tab["gene_id"]])
         gene_tab.to_csv(
             os.path.join("Tables", prefix + "_genes.tsv.gz"),
             sep="\t", index=False, compression="gzip",
@@ -246,6 +252,7 @@ def main(anname, gtf, outdir, cmp, combi, cores, spitopts):
         )
         ifs_out = ifs_df.copy()
         ifs_out.insert(0, "feature_id", ifs_out.index)
+        ifs_out.insert(ifs_out.columns.get_loc("gene_id") + 1, "Coordinates", [gene2coord.get(g, "NA") for g in ifs_out["gene_id"]])
         ifs_out.to_csv(
             os.path.join("Tables", prefix + "_ifs.tsv.gz"),
             sep="\t", index=False, compression="gzip",
diff --git a/scripts/lib/_lib.R b/scripts/lib/_lib.R
index 7b551306..fbe40116 100644
--- a/scripts/lib/_lib.R
+++ b/scripts/lib/_lib.R
@@ -36,6 +36,49 @@ get_exon_name <- function(id, df) {
     }
 }
 
+get_gene_coords <- function(id, df) {
+    if (!"gene_id" %in% colnames(df)) {
+        message("WARNING: gene_id not found as colname, will be replaced by first match of colname with ID")
+        colnames(df)[grepl("id$", names(df), ignore.case = TRUE)][1] <- "gene_id"
+    }
+    coord_rows <- df[df["type"] == "gene" & df["gene_id"] == id, ]
+    if (nrow(coord_rows) == 0) {
+        return(NA_character_)
+    }
+    coord_list <- paste(coord_rows$seqnames, coord_rows$start, coord_rows$end, coord_rows$strand, sep = ":")
+    if (length(unique(coord_list)) == 1) {
+        return(coord_list[1])
+    } else {
+        message(paste("WARNING: ambigous gene id: ", id))
+        return(paste(unique(coord_list), collapse = "|"))
+    }
+}
+
+
+add_gene_coordinates <- function(df, gene_ids, gtf_df, after = NULL) {
+    if (!"gene_id" %in% colnames(gtf_df)) {
+        message("WARNING: gene_id not found as colname, will be replaced by first match of colname with ID")
+        colnames(gtf_df)[grepl("id$", names(gtf_df), ignore.case = TRUE)][1] <- "gene_id"
+    }
+    df <- as.data.frame(df)
+    g <- gtf_df[gtf_df["type"] == "gene", ]
+    coords <- paste(g$seqnames, g$start, g$end, g$strand, sep = ":")
+    names(coords) <- as.character(g$gene_id)
+    df$Coordinates <- unname(coords[as.character(gene_ids)])
+    cols <- colnames(df)
+    cols <- cols[cols != "Coordinates"]
+    if (!is.null(after) && !is.na(after) && after %in% cols) {
+        pos <- match(after, cols)
+        new_order <- append(cols, "Coordinates", after = pos)
+    } else {
+        if (!is.null(after) && !is.na(after)) {
+            message(paste("WARNING: column", after, "not found, placing Coordinates first"))
+        }
+        new_order <- c("Coordinates", cols)
+    }
+    df[, new_order, drop = FALSE]
+}
+
 fpkmToTpm <- function(fpkm){
     exp(log(fpkm) - log(sum(fpkm)) + log(1e6))
 }

From c6e3953edf9cbd8150b0737a6151dbab6950db2e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 3 Jul 2026 13:26:10 +0200
Subject: [PATCH 05/80] major overhaul of pseudomapping and single-cell
 processing. Moved to rust implementation of salmon, added rammap as minimap
 alternative, alevin-fry/piscem and simpleaf as well as oarfish. salmon can
 nor quantify directly from spliced bam as intended by creators. optional dtu
 processing via terminus for more stable calling

---
 MONSDA/Workflows.py                  |  44 ++++++---
 configs/template.json                |   8 +-
 configs/template_base_commented.json |  96 ++++++++++++++++---
 configs/template_clean.json          |   8 +-
 configs/template_umicollapse.json    |   2 +-
 docs/source/config.rst               |   9 ++
 docs/source/workflows.rst            |  32 +++++--
 envs/alevinfry.yaml                  |   7 ++
 envs/minimap.yaml                    |   2 +-
 envs/oarfish.yaml                    |   8 ++
 envs/piscem.yaml                     |   8 ++
 envs/rammap.yaml                     |  12 +++
 envs/salmon.yaml                     |   5 +-
 envs/simpleaf.yaml                   |  10 ++
 envs/terminus.yaml                   |   7 ++
 tests/data/config_Test.json          |   2 +-
 tests/data/config_Test_local.json    |   2 +-
 workflows/alevinfry.nf               |  74 +++++++++++++++
 workflows/alevinfry.smk              |  34 +++++++
 workflows/dexseq_DTU.nf              |  36 +++++++-
 workflows/dexseq_DTU.smk             |  33 ++++++-
 workflows/drimseq_DTU.nf             |  36 +++++++-
 workflows/drimseq_DTU.smk            |  33 ++++++-
 workflows/oarfish.nf                 |  53 +++++++++++
 workflows/oarfish.smk                |  26 ++++++
 workflows/piscem.nf                  | 113 +++++++++++++++++++++++
 workflows/piscem.smk                 |  39 ++++++++
 workflows/rammap.nf                  | 118 ++++++++++++++++++++++++
 workflows/rammap.smk                 |  51 +++++++++++
 workflows/salmon.nf                  |  84 +++++++++++++----
 workflows/salmon.smk                 |  37 +++++++-
 workflows/salmonalign.nf             | 132 +++++++++++++++++++++++++++
 workflows/salmonalign.smk            |  55 +++++++++++
 workflows/simpleaf.nf                | 101 ++++++++++++++++++++
 workflows/simpleaf.smk               |  43 +++++++++
 workflows/spit_DTU.nf                |  36 +++++++-
 workflows/spit_DTU.smk               |  33 ++++++-
 37 files changed, 1355 insertions(+), 74 deletions(-)
 create mode 100644 envs/alevinfry.yaml
 create mode 100644 envs/oarfish.yaml
 create mode 100644 envs/piscem.yaml
 create mode 100644 envs/rammap.yaml
 create mode 100644 envs/simpleaf.yaml
 create mode 100644 envs/terminus.yaml
 create mode 100644 workflows/alevinfry.nf
 create mode 100644 workflows/alevinfry.smk
 create mode 100644 workflows/oarfish.nf
 create mode 100644 workflows/oarfish.smk
 create mode 100644 workflows/piscem.nf
 create mode 100644 workflows/piscem.smk
 create mode 100644 workflows/rammap.nf
 create mode 100644 workflows/rammap.smk
 create mode 100644 workflows/salmonalign.nf
 create mode 100644 workflows/salmonalign.smk
 create mode 100644 workflows/simpleaf.nf
 create mode 100644 workflows/simpleaf.smk

diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 2206e7bb..8f863430 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -958,7 +958,9 @@ def make_sub(
                                 subjobs.append(line)
                             subjobs.append("\n\n")
 
-                if "MAPPING" in works:
+                if "MAPPING" in works and envs[works.index("MAPPING")] not in [
+                    "piscem"
+                ]:
                     smkf = os.path.abspath(os.path.join(workflowpath, "mapping.smk"))
                     with open(smkf, "r") as smk:
                         for line in mu.comment_remover(smk.readlines()):
@@ -1152,16 +1154,21 @@ def make_sub(
                         subjobs.append("\n\n")
 
             if "MAPPING" in subworkflows:
-                smkf = os.path.abspath(os.path.join(workflowpath, "mapping.smk"))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(condapath, 'conda: "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line, loglevel, condapath, envpath, workflowpath, logfix
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                _map_tools, _ = create_subworkflow(config, "MAPPING", [condition])
+                _skip_postmap = _map_tools is not None and any(
+                    str(t[0]) in ["piscem"] for t in _map_tools
+                )
+                if not _skip_postmap:
+                    smkf = os.path.abspath(os.path.join(workflowpath, "mapping.smk"))
+                    with open(smkf, "r") as smk:
+                        for line in mu.comment_remover(smk.readlines()):
+                            line = re.sub(condapath, 'conda: "' + envpath, line)
+                            if "include: " in line:
+                                line = fixinclude(
+                                    line, loglevel, condapath, envpath, workflowpath, logfix
+                                )
+                            subjobs.append(line)
+                        subjobs.append("\n\n")
                 if "QC" in subworkflows:
                     # Use rustqc-specific multiqc whenever rustqc is part of this combo
                     _qc_tools, _ = create_subworkflow(config, "QC", [condition])
@@ -3106,6 +3113,7 @@ def nf_make_sub(
 
                     flowlist.append("MAPPING")
 
+                    maprad = envs[works.index("MAPPING")] in ["piscem"]
                     nfi = os.path.abspath(os.path.join(workflowpath, "mapping.nf"))
                     with open(nfi, "r") as nf:
                         for line in mu.comment_remover(nf.readlines()):
@@ -3197,9 +3205,10 @@ def nf_make_sub(
                             subjobs.append(" " * 4 + w + "(TRIMMING.out.trimmed)\n")
                         elif w == "MAPPING":
                             subjobs.append(" " * 4 + w + "(TRIMMING.out.trimmed)\n")
-                            subjobs.append(
-                                " " * 4 + "POSTMAPPING(MAPPING.out.mapped)\n"
-                            )
+                            if not maprad:
+                                subjobs.append(
+                                    " " * 4 + "POSTMAPPING(MAPPING.out.mapped)\n"
+                                )
                         elif w == "DEDUPBAM":
                             if deduptool == "fgumi":
                                 subjobs.append(
@@ -3471,6 +3480,10 @@ def nf_make_sub(
                     )
 
             if "MAPPING" in subworkflows:
+                _map_tools, _ = create_subworkflow(config, "MAPPING", [condition])
+                maprad = _map_tools is not None and any(
+                    str(t[0]) in ["piscem"] for t in _map_tools
+                )
                 if "QC" not in subworkflows:
                     log.debug(logid + "Mapping without QC!")
                 if "TRIMMING" not in subworkflows:
@@ -3580,7 +3593,8 @@ def nf_make_sub(
                         subjobs.append(" " * 4 + w + "(TRIMMING.out.trimmed)\n")
                     elif w == "MAPPING":
                         subjobs.append(" " * 4 + w + "(TRIMMING.out.trimmed)\n")
-                        subjobs.append(" " * 4 + "POSTMAPPING(MAPPING.out.mapped)\n")
+                        if not maprad:
+                            subjobs.append(" " * 4 + "POSTMAPPING(MAPPING.out.mapped)\n")
                     elif w == "DEDUPBAM":
                         if deduptool == "fgumi":
                             subjobs.append(
diff --git a/configs/template.json b/configs/template.json
index df2c2bfc..5ec96ff3 100644
--- a/configs/template.json
+++ b/configs/template.json
@@ -242,7 +242,7 @@
                                             "OPTIONS":
                                             {
                                                 "INDEX": "",  # salmon index options
-                                                "QUANT": "--validateMappings --seqBias --gcBias",  # salmon quant options
+                                                "QUANT": "--seqBias --gcBias",  # salmon quant options
                                             }
                                         }
                                     }
@@ -464,7 +464,7 @@
                         "OPTIONS":
                         {
                             "INDEX": "",  # salmon index options
-                            "QUANT": "--validateMappings --seqBias --gcBias",  # salmon quant options
+                            "QUANT": "--seqBias --gcBias",  # salmon quant options
                             "DTU": ""  # Options for Analysis
                         }
                     },
@@ -473,7 +473,7 @@
                         "OPTIONS":
                         {
                             "INDEX": "",  # salmon index options
-                            "QUANT": "--validateMappings --seqBias --gcBias",  # salmon quant options
+                            "QUANT": "--seqBias --gcBias",  # salmon quant options
                             "DTU": ""  # Options for Analysis
                         }
                     },
@@ -482,7 +482,7 @@
                         "OPTIONS":
                         {
                             "INDEX": "",  # salmon index options
-                            "QUANT": "--validateMappings --seqBias --gcBias",  # salmon quant options
+                            "QUANT": "--seqBias --gcBias",  # salmon quant options
                             "DTU": ""  # Options for Analysis
                         }
                     }
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index 32b5987e..b3e820ad 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -207,7 +207,10 @@
       "hisat2": "hisat2",
       "bwa": "bwa mem",
       "bwameth": "bwameth.py",
-      "minimap": "minimap2"
+      "minimap": "minimap2",
+      "salmonalign": "salmon",
+      "rammap": "rammap",
+      "piscem": "piscem"
     },
     "ENV" : "",
     "BIN" : "",
@@ -286,20 +289,53 @@
     "minimap": {
       "comment": {
         "INDEX" : "Indexing options",
-        "MAP": "Mapping options",
+        "MAP": "Mapping options, for long reads set the appropriate preset, e.g. -x map-ont (Nanopore) or -x map-pb (PacBio)",
         "EXTENSION" : "Prefix for index name, can be left empty."
       },
       "OPTIONS": {
           "INDEX" : "",
-          "MAP": "",
+          "MAP": "-x map-ont",
           "EXTENSION" : ""
       }
     },
+    "salmonalign": {
+      "comment": {
+        "INDEX" : "salmon index options, uses the salmon environment/container",
+        "MAP": "salmon quant options; salmon is run as a selective-alignment mapper (--writeMappings) emitting SAM for downstream postprocessing"
+      },
+      "OPTIONS": {
+          "INDEX" : "",
+          "MAP": ""
+      }
+    },
+    "rammap": {
+      "comment": {
+        "INDEX" : "minimap2 index options (rammap wraps a minimap2 index)",
+        "MAP": "rammap mapping options for long-read alignment"
+      },
+      "OPTIONS": {
+          "INDEX" : "",
+          "MAP": ""
+      }
+    },
+    "piscem": {
+      "comment": {
+        "INDEX" : "piscem build options (single-cell only)",
+        "MAP": "piscem map-sc options, requires single-cell read setup (R1 = barcode+UMI, R2 = cDNA)"
+      },
+      "OPTIONS": {
+          "INDEX" : "",
+          "MAP": ""
+      }
+    },
   },
   "COUNTING": {
     "TOOLS": {
       "countreads": "featureCounts",
-      "salmon": "salmon"
+      "salmon": "salmon",
+      "oarfish": "oarfish",
+      "alevinfry": "alevin-fry",
+      "simpleaf": "simpleaf"
     },
     "ENV" : "",
     "BIN" : "",
@@ -318,12 +354,45 @@
     "salmon": {
       "comment": {
           "INDEX": "salmon index options",
-          "QUANT": "salmon quant options"
+          "QUANT": "salmon quant options",
+          "BAM": "Optional: quantify from an aligned BAM instead of FASTQ. Leave empty for standard FASTQ mode. Set to 'transcriptome' for transcriptome-aligned BAMs or 'genome' for genome-aligned BAMs (requires GTF annotation)."
+      },
+      "OPTIONS":
+        {
+            "INDEX": "",
+            "QUANT": "--seqBias --gcBias",
+            "BAM": ""
+        }
+    },
+    "oarfish": {
+      "comment": {
+          "COUNT": "oarfish options for long-read transcript quantification from a transcriptome-aligned BAM"
+      },
+      "OPTIONS":
+        {
+            "COUNT": ""
+        }
+    },
+    "alevinfry": {
+      "comment": {
+          "PERMIT": "alevin-fry generate-permit-list options (single-cell only, consumes piscem RAD output)",
+          "COUNT": "alevin-fry quant options"
+      },
+      "OPTIONS":
+        {
+            "PERMIT": "-d fw --unfiltered-pl",
+            "COUNT": "-r cr-like --use-mtx"
+        }
+    },
+    "simpleaf": {
+      "comment": {
+          "INDEX": "simpleaf index options (single-cell, self-contained index + quant from FASTQ)",
+          "COUNT": "simpleaf quant options"
       },
       "OPTIONS":
         {
             "INDEX": "",
-            "QUANT": "--validateMappings --seqBias --gcBias"
+            "COUNT": ""
         }
     }
   },
@@ -526,11 +595,12 @@
       "comment": {
           "INDEX": "salmon index options, e.g. path to decoy file",
           "QUANT": "salmon quant options",
-          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ..."
+          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ...",
+          "TERMINUS": "Optional: enable terminus transcript grouping prior to DTU. Leave blank/absent to disable (default). Set terminus group options here (e.g. -m 0.1) to enable."
       },
       "OPTIONS": {
           "INDEX": "-d GENOMES/salmon_decoy",
-          "QUANT": "--validateMappings --seqBias --gcBias",
+          "QUANT": "--seqBias --gcBias",
           "DTU": ""
       }
     },
@@ -538,11 +608,12 @@
       "comment": {
           "INDEX": "salmon index options, e.g. path to decoy file",
           "QUANT": "salmon quant options",
-          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, , can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ..."
+          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, , can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ...",
+          "TERMINUS": "Optional: enable terminus transcript grouping prior to DTU. Leave blank/absent to disable (default). Set terminus group options here (e.g. -m 0.1) to enable."
       },
       "OPTIONS": {
           "INDEX": "-d GENOMES/salmon_decoy",
-          "QUANT": "--validateMappings --seqBias --gcBias",
+          "QUANT": "--seqBias --gcBias",
           "DTU": ""
       }
     },
@@ -550,11 +621,12 @@
       "comment": {
           "INDEX": "salmon index options, e.g. path to decoy file",
           "QUANT": "salmon quant options",
-          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ..."
+          "DTU": "Options for DTU Analysis, leave blank unless you know exactly what you are doing, can be used to set cutoffs for filtering, e.g. min_samps_feature_expr, min_gene_expr ...",
+          "TERMINUS": "Optional: enable terminus transcript grouping prior to DTU. Leave blank/absent to disable (default). Set terminus group options here (e.g. -m 0.1) to enable."
       },
       "OPTIONS": {
           "INDEX": "-d GENOMES/salmon_decoy",
-          "QUANT": "--validateMappings --seqBias --gcBias",
+          "QUANT": "--seqBias --gcBias",
           "DTU": ""
       }
     }
diff --git a/configs/template_clean.json b/configs/template_clean.json
index 7d5d4267..94e94949 100644
--- a/configs/template_clean.json
+++ b/configs/template_clean.json
@@ -233,7 +233,7 @@
           "OPTIONS":
             {
                 "INDEX": "",
-                "QUANT": "--validateMappings --seqBias --gcBias"
+                "QUANT": "--seqBias --gcBias"
             }
         }
       }
@@ -438,7 +438,7 @@
             "OPTIONS":
             {
                 "INDEX": "",
-                "QUANT": "--validateMappings --seqBias --gcBias",
+                "QUANT": "--seqBias --gcBias",
                 "DTU": ""
             }
         },
@@ -447,7 +447,7 @@
             "OPTIONS":
             {
                 "INDEX": "",
-                "QUANT": "--validateMappings --seqBias --gcBias",
+                "QUANT": "--seqBias --gcBias",
                 "DTU": ""
             }
         },
@@ -456,7 +456,7 @@
             "OPTIONS":
             {
                 "INDEX": "",
-                "QUANT": "--validateMappings --seqBias --gcBias",
+                "QUANT": "--seqBias --gcBias",
                 "DTU": ""
             }
         }
diff --git a/configs/template_umicollapse.json b/configs/template_umicollapse.json
index cff24128..e264259b 100644
--- a/configs/template_umicollapse.json
+++ b/configs/template_umicollapse.json
@@ -109,7 +109,7 @@
         "salmon": {
           "OPTIONS": {
             "INDEX": "-k 31",
-            "COUNTING": "-l U --validateMappings"
+            "COUNTING": "-l U"
           }
         }
       }
diff --git a/docs/source/config.rst b/docs/source/config.rst
index 022fe09d..bb918afe 100644
--- a/docs/source/config.rst
+++ b/docs/source/config.rst
@@ -34,6 +34,15 @@ You can always define differing ENV/BIN keys for each condition-tree leaf separa
 
 The next key-level is the *OPTIONS* key which is where you can define additional parameters for each tool. It is not needed to define anything related to *single-/paired-* end or *singlecell* sequencing, this is done automatically.  To add parameters simply add the *OPTION* key which defines a dict where you can set parameters for each defined subworkflow-step. Parameters are here defined as key/value pairs corresponding to the subworkflow-step, e.g. 'INDEX' to generate an index file for mapping and all settings similar to a command line call as values. This should become clear having a look at the different processing steps in the template json.  If there are no options just leave the 'OPTIONS' dict empty.
 
+.. note::
+
+  A few tool-specific options are worth highlighting:
+
+  * **salmon COUNTING from BAM**: in addition to the default FASTQ quantification, salmon can quantify directly from an alignment BAM by setting the ``BAM`` option to ``transcriptome`` (alignments against a transcriptome FASTA) or ``genome`` (alignments against the genome, requires the annotation GTF). Leave it empty/unset for the default FASTQ mode. Salmon indices are automatically rebuilt when the environment changes (salmon >= 2.3, ``--validateMappings`` is no longer needed).
+  * **long-read quantification**: use ``minimap`` with ``-x map-ont``/``-x map-pb`` (or ``rammap``) for mapping and ``oarfish`` for transcript quantification from the resulting transcriptome BAM.
+  * **single-cell**: use ``piscem`` as MAPPING tool (emits a RAD file, single-cell only, generic post-mapping is skipped) together with ``alevinfry`` as COUNTING tool, or use the self-contained ``simpleaf`` COUNTING tool.
+  * **DTU pre-grouping**: any DTU tool (drimseq/dexseq/spit) accepts an optional ``TERMINUS`` option to pre-group transcripts with terminus before analysis. It is disabled by default.
+
 
 .. literalinclude:: ../../configs/template.json
     :language: json
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index d9b75814..61b75be0 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -159,8 +159,14 @@ Maps sequences to reference genomes or transcriptomes
   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
   | BWA-Meth          | BWA-meth, Fast and accurante alignment of BS-Seq reads.                             | bwameth               | bwameth.py     | `bwa-meth <https://github.com/brentp/bwa-meth>`_                            | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | Minimap2     | Minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database.   | minimap              | minimap2    | `minimap <https://github.com/lh3/minimap2>`_                        | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+   | Minimap2     | Minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database. Use ``-x map-ont``/``-x map-pb`` for long-read (Nanopore/PacBio) mapping.   | minimap              | minimap2    | `minimap <https://github.com/lh3/minimap2>`_                        | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
+   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+   | salmonalign  | Salmon selective-alignment used as a mapper (``salmon quant --writeMappings``). Reuses the salmon environment/container.   | salmonalign          | salmon      | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_     | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
+   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+   | rammap       | Rust-accelerated long-read (Nanopore/PacBio) mapper (cargo-built, not on bioconda).                                        | rammap               | rammap      | `rammap <https://github.com/jwanglab/rammap>`_                      | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
+   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+   | piscem       | Fast single-cell/bulk mapper producing a RAD file for downstream alevin-fry quantification (single-cell only).             | piscem               | piscem      | `piscem <https://github.com/COMBINE-lab/piscem>`_                   | FASTQ/TRIMMED_FASTQ  | RAD         |
+   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
 
 
 DEDUP
@@ -200,10 +206,16 @@ Count (unique) mapped reads and how often they map to defined features
   +================+=======================================================================================================================+=============+================+==================================================================+======================+=========+
   | FeatureCounts  | A software program developed for counting reads to genomic features such as genes, exons, promoters and genomic bins  | countreads  | featureCounts  | `featurecounts <http://subread.sourceforge.net/>`_               | BAM/FASTQ            | TEXT    |
   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-  | Salmon         | Salmon is a tool for wicked-fast transcript quantification from RNA-seq data.                                         | salmon      | salmon         | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_  | FASTQ/TRIMMED_FASTQ  | TEXT    |
-  +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-  | Kallisto         | Kallisto is a program for quantifying abundances of transcripts from bulk and single-cell RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads. | kallisto      | kallisto         | `kallisto <https://pachterlab.github.io/kallisto/manual>`_  | FASTQ/TRIMMED_FASTQ  | TEXT    |
-  +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+   | Salmon         | Salmon is a tool for wicked-fast transcript quantification from RNA-seq data. Also supports quantification directly from an alignment BAM via the ``BAM`` option (``transcriptome`` or ``genome``).  | salmon      | salmon         | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_  | FASTQ/TRIMMED_FASTQ/BAM  | TEXT    |
+   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+   | Kallisto         | Kallisto is a program for quantifying abundances of transcripts from bulk and single-cell RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads. | kallisto      | kallisto         | `kallisto <https://pachterlab.github.io/kallisto/manual>`_  | FASTQ/TRIMMED_FASTQ  | TEXT    |
+   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+   | oarfish        | Long-read (Nanopore/PacBio) transcript quantification from a transcriptome-aligned BAM.                               | oarfish     | oarfish        | `oarfish <https://github.com/COMBINE-lab/oarfish>`_             | BAM                  | TEXT    |
+   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+   | alevin-fry     | Single-cell quantification consuming a piscem RAD file to produce a count matrix.                                     | alevinfry   | alevin-fry     | `alevin-fry <https://github.com/COMBINE-lab/alevin-fry>`_       | RAD                  | MATRIX  |
+   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+   | simpleaf       | Self-contained single-cell quantification wrapper (index + map + quant) around salmon/alevin-fry.                     | simpleaf    | simpleaf       | `simpleaf <https://github.com/COMBINE-lab/simpleaf>`_           | FASTQ/TRIMMED_FASTQ  | MATRIX  |
+   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
 
 
 Differential Analyses
@@ -234,8 +246,12 @@ Includes DE, DEU, DAS and DTU
    | DRIMSeq   | Differential Transcript Usage       | dmFilter()       |                 | DM             |                                 | pValue, LFC    | results(transcript, genes)                           | Proportions-table, genewise precision   | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | FeatPerGene, precision, Pvalues (per comparison)                  | ✓     |
    +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
    | SPIT      | Differential Transcript Usage       | IF-dominance     |                 | KDE            | Mann-Whitney U                  | pValue, LFC    | results(transcript, genes, ifs)                      | IF-table                                | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | PValues, Wasserstein (per comparison)                             | ✓     |
-   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-   
+    +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
+
+.. note::
+
+  For DTU analyses, transcripts can optionally be pre-grouped with `terminus <https://github.com/COMBINE-lab/terminus>`_ to collapse transcripts that cannot be confidently distinguished. This is disabled by default and enabled per DTU tool via the ``TERMINUS`` option.
+
 TRACKS
 ###############
 
diff --git a/envs/alevinfry.yaml b/envs/alevinfry.yaml
new file mode 100644
index 00000000..6e61d630
--- /dev/null
+++ b/envs/alevinfry.yaml
@@ -0,0 +1,7 @@
+name: alevinfry
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - alevin-fry >=0.11
diff --git a/envs/minimap.yaml b/envs/minimap.yaml
index 76c64bc4..7b536391 100644
--- a/envs/minimap.yaml
+++ b/envs/minimap.yaml
@@ -4,6 +4,6 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - minimap2 =2.24
+  - minimap2 >=2.28
   - pigz =2.6
   - samtools =1.21
\ No newline at end of file
diff --git a/envs/oarfish.yaml b/envs/oarfish.yaml
new file mode 100644
index 00000000..8b791a5b
--- /dev/null
+++ b/envs/oarfish.yaml
@@ -0,0 +1,8 @@
+name: oarfish
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - oarfish >=0.10
+  - samtools =1.21
diff --git a/envs/piscem.yaml b/envs/piscem.yaml
new file mode 100644
index 00000000..9b457f9a
--- /dev/null
+++ b/envs/piscem.yaml
@@ -0,0 +1,8 @@
+name: piscem
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - piscem >=0.20
+  - samtools =1.21
diff --git a/envs/rammap.yaml b/envs/rammap.yaml
new file mode 100644
index 00000000..79268aea
--- /dev/null
+++ b/envs/rammap.yaml
@@ -0,0 +1,12 @@
+name: rammap
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - rust >=1.75
+  - cargo
+  - git
+  - zlib
+  - pigz =2.6
+  - samtools =1.21
diff --git a/envs/salmon.yaml b/envs/salmon.yaml
index cfff7361..a5e45adb 100644
--- a/envs/salmon.yaml
+++ b/envs/salmon.yaml
@@ -2,5 +2,8 @@ name: salmon
 channels:
   - conda-forge
   - bioconda
+  - nodefaults
 dependencies:
-  - salmon =1.11.4
\ No newline at end of file
+  - salmon >=2.3
+  - samtools =1.21
+  - pigz =2.6
\ No newline at end of file
diff --git a/envs/simpleaf.yaml b/envs/simpleaf.yaml
new file mode 100644
index 00000000..af9d2e88
--- /dev/null
+++ b/envs/simpleaf.yaml
@@ -0,0 +1,10 @@
+name: simpleaf
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - simpleaf >=0.25
+  - piscem >=0.20
+  - alevin-fry >=0.11
+  - pyroe
diff --git a/envs/terminus.yaml b/envs/terminus.yaml
new file mode 100644
index 00000000..2398124b
--- /dev/null
+++ b/envs/terminus.yaml
@@ -0,0 +1,7 @@
+name: terminus
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - terminus
diff --git a/tests/data/config_Test.json b/tests/data/config_Test.json
index e7eededd..98eb5124 100644
--- a/tests/data/config_Test.json
+++ b/tests/data/config_Test.json
@@ -255,7 +255,7 @@
             "drimseq": {
                 "OPTIONS": {
                     "INDEX": "-d GENOMES/transcripts.fa.gz",
-                    "QUANT": "--validateMappings --seqBias --gcBias",
+                    "QUANT": "--seqBias --gcBias",
                     "DTU": ""
                 }
             }
diff --git a/tests/data/config_Test_local.json b/tests/data/config_Test_local.json
index 19bc01a5..5b6a4709 100644
--- a/tests/data/config_Test_local.json
+++ b/tests/data/config_Test_local.json
@@ -255,7 +255,7 @@
             "drimseq": {
                 "OPTIONS": {
                     "INDEX": "-d GENOMES/transcripts.fa.gz",
-                    "QUANT": "--validateMappings --seqBias --gcBias",
+                    "QUANT": "--seqBias --gcBias",
                     "DTU": ""
                 }
             }
diff --git a/workflows/alevinfry.nf b/workflows/alevinfry.nf
new file mode 100644
index 00000000..9ce314b0
--- /dev/null
+++ b/workflows/alevinfry.nf
@@ -0,0 +1,74 @@
+COUNTENV = get_always('COUNTINGENV')
+COUNTBIN = get_always('COUNTINGBIN')
+COUNTREF = get_always('COUNTINGREF')
+COUNTREFDIR = "${workflow.workDir}/../"+get_always('COUNTINGREFDIR')
+COUNTANNO = get_always('COUNTINGANNO')
+COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
+
+COUNTPARAMS = get_always('alevinfry_params_COUNT') ?: ''
+PERMITPARAMS = get_always('alevinfry_params_PERMIT') ?: '--unfiltered-pl'
+
+//COUNTING PROCESSES
+
+process generate_t2g{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus 1
+	cache 'lenient'
+
+    input:
+    path anno
+
+    output:
+    path "t2g.tsv", emit: t2g
+
+    script:
+    """
+    zcat $anno | awk 'BEGIN{FS="\\t";OFS="\\t"} \$3=="transcript"{match(\$9,/transcript_id "[^"]+"/); t=substr(\$9,RSTART+15,RLENGTH-16); match(\$9,/gene_id "[^"]+"/); g=substr(\$9,RSTART+9,RLENGTH-10); print t,g}' > t2g.tsv
+    """
+}
+
+process alevinfry_quant{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/alevinfry/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/alevinfry/${CONDITION}/${file(filename).getName()}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*_afquant", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    t2g = reads[0]
+    raddir = reads[1]
+    fn = file(raddir).getSimpleName().replaceAll(/\Q_map\E/,"")
+    qd = fn+"_afquant"
+    lf = "alevinfry_"+fn+".log"
+    """
+    $COUNTBIN generate-permit-list -i $raddir -d fw $PERMITPARAMS -o $qd &> $lf; $COUNTBIN collate -i $qd -r $raddir -t ${task.cpus} &>> $lf; $COUNTBIN quant -i $qd -m $t2g -t ${task.cpus} -r cr-like $COUNTPARAMS -o $qd --use-mtx &>> $lf
+    """
+}
+
+workflow COUNTING{
+    take: collection
+
+    main:
+
+    radsamples = collection.filter(~/map.rad/)
+    annofile = Channel.fromPath(COUNTANNO)
+    generate_t2g(annofile)
+    alevinfry_quant(generate_t2g.out.t2g.combine(radsamples.map{it -> file(it).getParent()}))
+
+    emit:
+    counts = alevinfry_quant.out.counts
+    logs = alevinfry_quant.out.logs
+}
diff --git a/workflows/alevinfry.smk b/workflows/alevinfry.smk
new file mode 100644
index 00000000..ee91fcd7
--- /dev/null
+++ b/workflows/alevinfry.smk
@@ -0,0 +1,34 @@
+COUNTBIN, COUNTENV = env_bin_from_config(config,'COUNTING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'COUNTING', COUNTENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = COUNTENV
+unik = get_dict_hash(keydict)
+
+rule themall:
+    input:  expand("COUNTS/{combo}/{file}/alevin/quants_mat.mtx.gz", combo=combo, file=samplecond(SAMPLES, config))
+
+rule generate_t2g:
+    input:  anno = ANNOTATION
+    output: t2g = expand("{refd}/INDICES/{cenv}_{unikey}/t2g.tsv", refd=REFDIR, cenv=COUNTENV, unikey=unik)
+    log:    expand("LOGS/{sets}/{cenv}.t2g.log", sets=SETS, cenv=COUNTENV)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    shell:  "mkdir -p $(dirname {output.t2g}); zcat {input.anno} | awk 'BEGIN{{FS=\"\\t\";OFS=\"\\t\"}} $3==\"transcript\"{{match($9,/transcript_id \"[^\"]+\"/); t=substr($9,RSTART+15,RLENGTH-16); match($9,/gene_id \"[^\"]+\"/); g=substr($9,RSTART+9,RLENGTH-10); print t,g}}' > {output.t2g} 2> {log}"
+
+rule counting:
+    input:  rad = "MAPPED/{combo}/{file}",
+            radfile = "MAPPED/{combo}/{file}/map.rad",
+            t2g = rules.generate_t2g.output.t2g
+    output: cnts = report("COUNTS/{combo}/{file}/alevin/quants_mat.mtx.gz", category="COUNTING"),
+            ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
+    log:    "LOGS/{combo}/{file}/alevinfryquant.log"
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', ""),
+            ppara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('PERMIT', "--unfiltered-pl"),
+            mapp = COUNTBIN,
+            quantdir = lambda wildcards, output: os.path.join(str(output.ctsdir), "af_quant")
+    shell: "{params.mapp} generate-permit-list -i {input.rad} -d fw {params.ppara} -o {params.quantdir} &> {log}; {params.mapp} collate -i {params.quantdir} -r {input.rad} -t {threads} &>> {log}; {params.mapp} quant -i {params.quantdir} -m {input.t2g} -t {threads} -r cr-like {params.cpara} -o {params.quantdir} --use-mtx &>> {log} && mkdir -p $(dirname {output.cnts}) && gzip -c {params.quantdir}/alevin/quants_mat.mtx > {output.cnts} 2>> {log}"
diff --git a/workflows/dexseq_DTU.nf b/workflows/dexseq_DTU.nf
index edbd2a82..aa36fc82 100644
--- a/workflows/dexseq_DTU.nf
+++ b/workflows/dexseq_DTU.nf
@@ -11,6 +11,7 @@ DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
 IDXPARAMS = get_always('dexseq_DTU_params_INDEX') ?: ''
 COUNTPARAMS = get_always('dexseq_DTU_params_COUNT') ?: ''
 DTUPARAMS = get_always('dexseq_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('dexseq_DTU_params_TERMINUS') ?: ''
 DTUREPS = get_always('DTUREPS') ?: ''
 DTUCOMP = get_always('DTUCOMP') ?: ''
 DTUCOMPS = get_always('DTUCOMPS') ?: ''
@@ -228,6 +229,32 @@ process collect_dexseq{
     """
 }
 
+process terminus_collapse{
+    conda "terminus.yaml"
+    container "oras://jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+
+    input:
+    path counts
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+
 workflow DTU{ 
     take: collection
 
@@ -260,7 +287,14 @@ workflow DTU{
     }
 
     prepare_dtu_annotation()
-    run_dexseq(salmon_quant.out.counts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_dexseq(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
     create_summary_snippet(run_dexseq.out.tbls.concat(run_dexseq.out.figs.concat(run_dexseq.out.session)).collect())
     collect_dexseq(run_dexseq.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
 
diff --git a/workflows/dexseq_DTU.smk b/workflows/dexseq_DTU.smk
index 5eb7b6c6..79187ab8 100644
--- a/workflows/dexseq_DTU.smk
+++ b/workflows/dexseq_DTU.smk
@@ -7,6 +7,10 @@ comparison = comparable_as_string(config,'DTU')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
 
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
 keydict["REF"] = REFERENCE
 keydict["DECOY"] = DECOY
@@ -92,8 +96,35 @@ else:
         shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
 
 
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+
 rule create_annotation_table:
-    input:  dir  = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config)),
+    input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"
diff --git a/workflows/drimseq_DTU.nf b/workflows/drimseq_DTU.nf
index b5d814bb..dbc28e22 100644
--- a/workflows/drimseq_DTU.nf
+++ b/workflows/drimseq_DTU.nf
@@ -11,6 +11,7 @@ DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
 IDXPARAMS = get_always('drimseq_DTU_params_INDEX') ?: ''
 COUNTPARAMS = get_always('drimseq_DTU_params_COUNT') ?: ''
 DTUPARAMS = get_always('drimseq_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('drimseq_DTU_params_TERMINUS') ?: ''
 DTUREPS = get_always('DTUREPS') ?: ''
 DTUCOMP = get_always('DTUCOMP') ?: ''
 DTUCOMPS = get_always('DTUCOMPS') ?: ''
@@ -229,6 +230,32 @@ process collect_drimseq{
     """
 }
 
+process terminus_collapse{
+    conda "terminus.yaml"
+    container "oras://jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+
+    input:
+    path counts
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+
 workflow DTU{ 
     take: collection
 
@@ -261,7 +288,14 @@ workflow DTU{
     }
 
     prepare_dtu_annotation()
-    run_drimseq(salmon_quant.out.counts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_drimseq(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
     create_summary_snippet(run_drimseq.out.tbls.concat(run_drimseq.out.figs.concat(run_drimseq.out.session)).collect())
     collect_drimseq(run_drimseq.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
 
diff --git a/workflows/drimseq_DTU.smk b/workflows/drimseq_DTU.smk
index 597ccb53..db41825a 100644
--- a/workflows/drimseq_DTU.smk
+++ b/workflows/drimseq_DTU.smk
@@ -7,6 +7,10 @@ comparison = comparable_as_string(config,'DTU')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
 
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
 keydict["REF"] = REFERENCE
 keydict["DECOY"] = DECOY
@@ -100,8 +104,35 @@ else:
         shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
 
 
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+
 rule create_annotation_table:
-    input:  dir  = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config)),
+    input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"
diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
new file mode 100644
index 00000000..d40851dc
--- /dev/null
+++ b/workflows/oarfish.nf
@@ -0,0 +1,53 @@
+COUNTENV = get_always('COUNTINGENV')
+COUNTBIN = get_always('COUNTINGBIN')
+COUNTREF = get_always('COUNTINGREF')
+COUNTREFDIR = "${workflow.workDir}/../"+get_always('COUNTINGREFDIR')
+COUNTANNO = get_always('COUNTINGANNO')
+COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
+
+COUNTPARAMS = get_always('oarfish_params_COUNT') ?: ''
+
+//COUNTING PROCESSES
+
+process oarfish_quant{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/oarfish/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/oarfish/${CONDITION}/${file(filename).getName()}"
+    }
+
+    input:
+    path bam
+
+    output:
+    path "*.gz", includeInputs:false, emit: counts
+    path "*.log", emit: logs
+    path "*", includeInputs:false, emit: rest
+
+    script:
+    fn = file(bam).getSimpleName().replaceAll(/\Q_mapped_sorted\E/,"")
+    lf = "oarfish_"+fn+".log"
+    oz = fn+"/quant.sf.gz"
+    ol = fn+"_counts.gz"
+    """
+    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $COUNTANNO --reference $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
+    """
+}
+
+workflow COUNTING{
+    take: collection
+
+    main:
+
+    bamsamples = collection.filter(~/.bam/)
+    oarfish_quant(bamsamples)
+
+    emit:
+    counts = oarfish_quant.out.counts
+    logs = oarfish_quant.out.logs
+}
diff --git a/workflows/oarfish.smk b/workflows/oarfish.smk
new file mode 100644
index 00000000..dc40b078
--- /dev/null
+++ b/workflows/oarfish.smk
@@ -0,0 +1,26 @@
+COUNTBIN, COUNTENV = env_bin_from_config(config,'COUNTING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'COUNTING', COUNTENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = COUNTENV
+unik = get_dict_hash(keydict)
+
+rule themall:
+    input:  expand("COUNTS/{combo}/{file}_counts.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+
+rule mapping:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+            anno = ANNOTATION,
+            fa = REFERENCE
+    output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
+            ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
+    log:    "LOGS/{combo}/{file}/oarfishquant.log"
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', ""),
+            mapp = COUNTBIN,
+            nbam = lambda wildcards, output: os.path.join(str(output.ctsdir), "namecollated.bam"),
+            prefix = lambda wildcards, output: os.path.join(str(output.ctsdir), "oarfish"),
+            linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+    shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {input.anno} --reference {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
diff --git a/workflows/piscem.nf b/workflows/piscem.nf
new file mode 100644
index 00000000..830f68ba
--- /dev/null
+++ b/workflows/piscem.nf
@@ -0,0 +1,113 @@
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX') ?: 'piscem_idx'
+
+IDXPARAMS = get_always('piscem_params_INDEX') ?: ''
+MAPPARAMS = get_always('piscem_params_MAP') ?: ''
+
+
+//MAPPING PROCESSES
+
+process collect_tomap{
+    input:
+    path check
+
+    output:
+    path "collect.txt", emit: done
+
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+
+process piscem_idx{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "piscem.idx")                  "$MAPIDX"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/piscem_index.log"
+        else                                            "$MAPUIDXNAME"
+    }
+
+    input:
+    path genome
+
+    output:
+    path "$MAPUIDXNAME", emit: idx
+    path "*index.log", emit: idxlog
+
+    script:
+    gen =  genome.getName()
+    """
+    mkdir -p $MAPUIDXNAME && zcat $gen > ref.fa && $MAPBIN build -t ${task.cpus} $IDXPARAMS -s ref.fa -o $MAPUIDXNAME/$MAPPREFIX &> index.log && rm -f ref.fa && ln -fs $MAPUIDXNAME piscem.idx
+    """
+
+}
+
+process piscem_mapping{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else                                       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*_map", emit: maps
+    path "*.log", emit: logs
+
+    script:
+    idxdir = reads[0]
+    r1 = reads[1]
+    r2 = reads[2]
+    fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+    of = fn+"_map"
+    lf = "piscem_"+fn+".log"
+    """
+    $MAPBIN map-sc -t ${task.cpus} $MAPPARAMS -i $idxdir/$MAPPREFIX -1 $r1 -2 $r2 -o $of &> $lf
+    """
+}
+
+workflow MAPPING{
+    take: collection
+
+    main:
+
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        piscem_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        piscem_idx(genomefile)
+        piscem_mapping(piscem_idx.out.idx.combine(collection))
+    }
+
+
+    emit:
+    mapped  = piscem_mapping.out.maps
+    logs = piscem_mapping.out.logs
+}
diff --git a/workflows/piscem.smk b/workflows/piscem.smk
new file mode 100644
index 00000000..ba001850
--- /dev/null
+++ b/workflows/piscem.smk
@@ -0,0 +1,39 @@
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.sshash", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda:  ""+MAPPERENV+".yaml"
+    container: "oras://jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: indexer = MAPPERBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found index, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && mkdir -p {output.uidx} && {params.indexer} build -t {threads} {params.ipara} -s {output.tmpfa} -o {output.uidx}/{params.pref} &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx};fi"
+
+rule mapping:
+    input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+            r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+            uidx = rules.generate_index.output.uidx[0],
+            dummy = rules.generate_index.output.idxfile
+    output: rad = directory("MAPPED/{combo}/{file}"),
+            radfile = "MAPPED/{combo}/{file}/map.rad"
+    log:    "LOGS/{combo}/{file}/mapping.log"
+    conda:  ""+MAPPERENV+".yaml"
+    container: "oras://jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+            mapp = MAPPERBIN,
+            pref = PREFIX,
+            idxpref = lambda wildcards, input: os.path.join(str(input.uidx), PREFIX)
+    shell: "{params.mapp} map-sc -t {threads} {params.mpara} -i {params.idxpref} -1 {input.r1} -2 {input.r2} -o {output.rad} &> {log}"
diff --git a/workflows/rammap.nf b/workflows/rammap.nf
new file mode 100644
index 00000000..c0b8d0ba
--- /dev/null
+++ b/workflows/rammap.nf
@@ -0,0 +1,118 @@
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+
+IDXPARAMS = get_always('rammap_params_INDEX') ?: ''
+MAPPARAMS = get_always('rammap_params_MAP') ?: ''
+
+RAMMAPBUILD = 'command -v rammap >/dev/null 2>&1 || cargo install --git https://github.com/jwanglab/rammap --root ${CONDA_PREFIX:-$PWD/.cargo} ; export PATH=${CONDA_PREFIX:-$PWD/.cargo}/bin:$PATH; '
+
+//MAPPING PROCESSES
+
+process rammap_idx{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "rammap.idx")                  "$MAPIDX"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/rammap_index.log"
+        else                                            "$MAPUIDX"
+    }
+
+    input:
+    path genome
+
+    output:
+    path "*.idx", emit: idx
+    path "$MAPUIDXNAME", emit: uidx
+
+    script:
+    gen =  genome.getName()
+    """
+    ${RAMMAPBUILD} $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS $gen &> index.log && ln -fs $MAPUIDXNAME rammap.idx
+    """
+
+}
+
+process rammap_mapping{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else null
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*.sam.gz", emit: maps
+    path "*fastq.gz", includeInputs:false, emit: unmapped
+    path "*.log", emit: logs
+
+    script:    
+    idxfile = reads[0]
+    idx = idxfile.getName()
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf1 = fn+"_R1_unmapped.fastq.gz"
+        uf2 = fn+"_R2_unmapped.fastq.gz"
+        lf = "rammap_"+fn+".log"
+        """
+        ${RAMMAPBUILD} $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        """
+    }else{
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf = fn+"_unmapped.fastq.gz"
+        lf = "rammap_"+fn+".log"
+        """
+        ${RAMMAPBUILD} $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        """
+    }
+}
+
+workflow MAPPING{
+    take: collection
+
+    main:
+ 
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+    
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)       
+        rammap_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        rammap_idx(genomefile)        
+        rammap_mapping(rammap_idx.out.idx.combine(collection))
+    }
+
+
+    emit:
+    mapped  = rammap_mapping.out.maps
+    logs = rammap_mapping.out.logs
+}
diff --git a/workflows/rammap.smk b/workflows/rammap.smk
new file mode 100644
index 00000000..67ee74c1
--- /dev/null
+++ b/workflows/rammap.smk
@@ -0,0 +1,51 @@
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+
+rammapbuild = 'command -v rammap >/dev/null 2>&1 || cargo install --git https://github.com/jwanglab/rammap --root ${{CONDA_PREFIX:-$PWD/.cargo}} >> {log} 2>&1; export PATH=${{CONDA_PREFIX:-$PWD/.cargo}}/bin:$PATH; '
+
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = INDEX,
+            uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda:  ""+MAPPERENV+".yaml"
+    container: "oras://jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: indexer=MAPPERBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell: rammapbuild + "{params.indexer} -t {threads} -d {output.uidx} {params.ipara} {input.fa} 2> {log} && ln -s {params.linkidx} {output.idx}"
+
+if paired == 'paired':
+    rule mapping:
+        input:  q1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                q2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0]
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda:  ""+MAPPERENV+".yaml"
+        container: "oras://jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN
+        shell: rammapbuild + "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.q1} {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+
+else:
+    rule mapping:
+        input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0]
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda:  ""+MAPPERENV+".yaml"
+        container: "oras://jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN
+        shell: rammapbuild + "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index 13c0092c..a63f1576 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -12,6 +12,7 @@ COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
 
 IDXPARAMS = get_always('salmon_params_INDEX') ?: ''
 COUNTPARAMS = get_always('salmon_params_COUNT') ?: ''
+BAMMODE = get_always('salmon_params_BAM') ?: ''
 
 //COUNTING PROCESSES
 
@@ -152,33 +153,80 @@ process salmon_quant{
     }
 }
 
+process salmon_quant_bam{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/salmon/${CONDITION}/${file(filename).getName()}"
+    }
+
+    input:
+    path bam
+
+    output:
+    path "*.gz", includeInputs:false, emit: counts
+    path "*.log", emit: logs
+    path "*", includeInputs:false, emit: rest
+
+    script:
+    fn = file(bam).getSimpleName().replaceAll(/\Q_mapped_sorted\E/,"")
+    lf = "salmon_"+fn+".log"
+    of = fn+"/quant.sf"
+    oz = fn+"/quant.sf.gz"
+    ol = fn+"_counts.gz"
+    if (BAMMODE == 'genome'){
+        """
+        mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN quant -p ${task.cpus} -a namecollated.bam --annotation $COUNTANNO --genome $COUNTREF $COUNTPARAMS -o $fn &>> $lf && rm -f namecollated.bam && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        """
+        mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN quant -p ${task.cpus} -t $COUNTREF -a namecollated.bam --deterministic $COUNTPARAMS -o $fn &>> $lf && rm -f namecollated.bam && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+
 workflow COUNTING{
     take: collection
 
     main:
    
-    checkidx = file(COUNTUIDX)
-    collection.filter(~/.fastq.gz/)
-    
-    if (checkidx.exists()){
-        idxfile = Channel.fromPath(COUNTUIDX)
-        if (PAIRED == 'paired'){
-            salmon_quant(idxfile.combine(samples_ch.collate(2)))
-        } else{
-            salmon_quant(idxfile.combine(samples_ch.collate(1)))
-        }        
+    if (BAMMODE?.length() > 0){
+        bamsamples = collection.filter(~/.bam/)
+        salmon_quant_bam(bamsamples)
+        outcounts = salmon_quant_bam.out.counts
+        outlogs = salmon_quant_bam.out.logs
     }
     else{
-        genomefile = Channel.fromPath(COUNTREF)
-        salmon_idx(genomefile)
-        if (PAIRED == 'paired'){
-            salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(2)))
-        } else{
-            salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(1)))
+        checkidx = file(COUNTUIDX)
+        collection.filter(~/.fastq.gz/)
+
+        if (checkidx.exists()){
+            idxfile = Channel.fromPath(COUNTUIDX)
+            if (PAIRED == 'paired'){
+                salmon_quant(idxfile.combine(samples_ch.collate(2)))
+            } else{
+                salmon_quant(idxfile.combine(samples_ch.collate(1)))
+            }        
+        }
+        else{
+            genomefile = Channel.fromPath(COUNTREF)
+            salmon_idx(genomefile)
+            if (PAIRED == 'paired'){
+                salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(2)))
+            } else{
+                salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(1)))
+            }
         }
+        outcounts = salmon_quant.out.counts
+        outlogs = salmon_quant.out.logs
     }
 
     emit:
-    counts = salmon_quant.out.counts
-    logs = salmon_quant.out.logs
+    counts = outcounts
+    logs = outlogs
 }
diff --git a/workflows/salmon.smk b/workflows/salmon.smk
index 621cc99a..afd8ba11 100644
--- a/workflows/salmon.smk
+++ b/workflows/salmon.smk
@@ -5,6 +5,8 @@ keydict["DECOY"] = DECOY
 keydict["ENV"] = COUNTENV
 unik = get_dict_hash(keydict)
 
+bammode = tool_params(SAMPLES[0], None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('BAM', "").lower()
+
 rule themall:
     input:  expand("COUNTS/{combo}/{file}_counts.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
 
@@ -23,9 +25,40 @@ rule salmon_index:
     shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
 
 
-if paired == 'paired':
+if bammode == 'transcriptome':
+    rule mapping:
+        input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+                fa = REFERENCE
+        output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', ""),
+                mapp=COUNTBIN,
+                nbam = lambda wildcards, output: os.path.join(str(output.ctsdir), "namecollated.bam"),
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} quant -p {threads} -t {input.fa} -a {params.nbam} --deterministic {params.cpara} -o {output.ctsdir} &>> {log} && rm -f {params.nbam} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+elif bammode == 'genome':
     rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+        input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+                anno = ANNOTATION,
+                fa = REFERENCE
+        output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', ""),
+                mapp=COUNTBIN,
+                nbam = lambda wildcards, output: os.path.join(str(output.ctsdir), "namecollated.bam"),
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} quant -p {threads} -a {params.nbam} --annotation {input.anno} --genome {input.fa} {params.cpara} -o {output.ctsdir} &>> {log} && rm -f {params.nbam} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+elif paired == 'paired':
                 r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
diff --git a/workflows/salmonalign.nf b/workflows/salmonalign.nf
new file mode 100644
index 00000000..7ec05eb3
--- /dev/null
+++ b/workflows/salmonalign.nf
@@ -0,0 +1,132 @@
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+MAPYAML = MAPBIN
+
+IDXPARAMS = get_always('salmonalign_params_INDEX') ?: ''
+MAPPARAMS = get_always('salmonalign_params_MAP') ?: ''
+
+
+//MAPPING PROCESSES
+
+process salmonalign_idx{
+    conda "$MAPYAML"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPYAML"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "salmonalign.idx")              "$MAPIDX"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/salmonalign_index.log"
+        else                                            "$MAPUIDX"
+    }
+
+    input:
+    path genome
+
+    output:
+    path "*.idx", emit: idx
+    path "$MAPUIDXNAME", emit: uidx
+
+    script:
+    gen =  genome.getName()
+    """
+    $MAPBIN index $IDXPARAMS -p ${task.cpus} -t $gen -i $MAPUIDXNAME &> index.log && ln -fs $MAPUIDXNAME salmonalign.idx
+    """
+
+}
+
+process salmonalign_mapping{
+    conda "$MAPYAML"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPYAML"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else null
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*.sam.gz", emit: maps
+    path "*fastq.gz", includeInputs:false, emit: unmapped
+    path "*.log", emit: logs
+
+    script:    
+    idxfile = reads[0]
+    idx = idxfile.getName()
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        r1 = reads[1]
+        r2 = reads[2]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf1 = fn+"_R1_unmapped.fastq.gz"
+        uf2 = fn+"_R2_unmapped.fastq.gz"
+        lf = "salmonalign_"+fn+".log"
+        """
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings -o $fn -1 $r1 -2 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf = fn+"_unmapped.fastq.gz"
+        lf = "salmonalign_"+fn+".log"
+        """
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings -o $fn -r $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        """
+    }
+}
+
+workflow MAPPING{
+    take: collection
+
+    main:
+ 
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+    
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)       
+        salmonalign_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        salmonalign_idx(genomefile)        
+        salmonalign_mapping(salmonalign_idx.out.idx.combine(collection))
+    }
+
+
+    emit:
+    mapped  = salmonalign_mapping.out.maps
+    logs = salmonalign_mapping.out.logs
+}
diff --git a/workflows/salmonalign.smk b/workflows/salmonalign.smk
new file mode 100644
index 00000000..b298f74a
--- /dev/null
+++ b/workflows/salmonalign.smk
@@ -0,0 +1,55 @@
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+MAPPERYAML = MAPPERBIN
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda:  ""+MAPPERYAML+".yaml"
+    container: "oras://jfallmann/monsda:"+MAPPERYAML+""
+    threads: MAXTHREAD
+    params: indexer=MAPPERBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell: "set +euo pipefail; {params.indexer} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+
+if paired == 'paired':
+    rule mapping:
+        input:  q1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                q2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0]
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda:  ""+MAPPERYAML+".yaml"
+        container: "oras://jfallmann/monsda:"+MAPPERYAML+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                outdir = lambda wildcards: "MAPPED/"+wildcards.combo+"/"+wildcards.file+"_salmonalign"
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings -o {params.outdir} -1 {input.q1} -2 {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+
+else:
+    rule mapping:
+        input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0]
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda:  ""+MAPPERYAML+".yaml"
+        container: "oras://jfallmann/monsda:"+MAPPERYAML+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                outdir = lambda wildcards: "MAPPED/"+wildcards.combo+"/"+wildcards.file+"_salmonalign"
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings -o {params.outdir} -r {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
diff --git a/workflows/simpleaf.nf b/workflows/simpleaf.nf
new file mode 100644
index 00000000..bd6ed619
--- /dev/null
+++ b/workflows/simpleaf.nf
@@ -0,0 +1,101 @@
+COUNTENV = get_always('COUNTINGENV')
+COUNTBIN = get_always('COUNTINGBIN')
+COUNTIDX = get_always('COUNTINGIDX')
+COUNTUIDX = get_always('COUNTINGUIDX')
+COUNTUIDX = COUNTUIDX.replaceAll('.idx','')
+COUNTUIDXNAME = get_always('COUNTINGUIDXNAME')
+COUNTREF = get_always('COUNTINGREF')
+COUNTREFDIR = "${workflow.workDir}/../"+get_always('COUNTINGREFDIR')
+COUNTANNO = get_always('COUNTINGANNO')
+COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
+
+IDXPARAMS = get_always('simpleaf_params_INDEX') ?: '--ref-type spliced+unspliced'
+COUNTPARAMS = get_always('simpleaf_params_COUNT') ?: '--chemistry 10xv3 --resolution cr-like --expected-ori fw --unfiltered-pl'
+
+//COUNTING PROCESSES
+
+process simpleaf_idx{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename == "simpleaf.idx")            "$COUNTIDX"
+        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/simpleaf_index.log"
+        else                                      "$COUNTUIDX"
+    }
+
+    input:
+    path genome
+    path anno
+
+    output:
+    path "$COUNTUIDXNAME", emit: idx
+    path "*.log", emit: idxlog
+
+    script:
+    gen =  genome.getName()
+    an = anno.getName()
+    """
+    export ALEVIN_FRY_HOME=\$PWD/af_home; mkdir -p \$ALEVIN_FRY_HOME; $COUNTBIN set-paths &> index.log; zcat $gen > ref.fa && zcat $an > ref.gtf && $COUNTBIN index --fasta ref.fa --gtf ref.gtf -t ${task.cpus} $IDXPARAMS -o $COUNTUIDXNAME &>> index.log && rm -f ref.fa ref.gtf && ln -fs $COUNTUIDXNAME simpleaf.idx
+    """
+
+}
+
+process simpleaf_quant{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/simpleaf/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/simpleaf/${CONDITION}/${file(filename).getName()}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*_afquant", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    idx = reads[0]
+    rs = reads[1..2].sort()
+    r1 = rs[0]
+    r2 = rs[1]
+    fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+    qd = fn+"_afquant"
+    lf = "simpleaf_"+fn+".log"
+    """
+    export ALEVIN_FRY_HOME=\$PWD/af_home; mkdir -p \$ALEVIN_FRY_HOME; $COUNTBIN set-paths &> $lf; $COUNTBIN quant --index $idx/index --reads1 $r1 --reads2 $r2 -t ${task.cpus} $COUNTPARAMS -o $qd &>> $lf
+    """
+}
+
+workflow COUNTING{
+    take: collection
+
+    main:
+
+    checkidx = file(COUNTUIDX)
+    collection.filter(~/.fastq.gz/)
+
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(COUNTUIDX)
+        simpleaf_quant(idxfile.combine(samples_ch.collate(2)))
+    }
+    else{
+        genomefile = Channel.fromPath(COUNTREF)
+        annofile = Channel.fromPath(COUNTANNO)
+        simpleaf_idx(genomefile, annofile)
+        simpleaf_quant(simpleaf_idx.out.idx.combine(samples_ch.collate(2)))
+    }
+
+    emit:
+    counts = simpleaf_quant.out.counts
+    logs = simpleaf_quant.out.logs
+}
diff --git a/workflows/simpleaf.smk b/workflows/simpleaf.smk
new file mode 100644
index 00000000..06a1c38a
--- /dev/null
+++ b/workflows/simpleaf.smk
@@ -0,0 +1,43 @@
+COUNTBIN, COUNTENV = env_bin_from_config(config,'COUNTING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'COUNTING', COUNTENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = COUNTENV
+unik = get_dict_hash(keydict)
+
+rule themall:
+    input:  expand("COUNTS/{combo}/{file}/af_quant/alevin/quants_mat.mtx.gz", combo=combo, file=samplecond(SAMPLES, config))
+
+rule generate_index:
+    input:  fa = REFERENCE,
+            anno = ANNOTATION
+    output: idx = directory(expand("{refd}/INDICES/{cenv}_{unikey}", refd=REFDIR, cenv=COUNTENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{cenv}_{unikey}/index/info.json", refd=REFDIR, cenv=COUNTENV, unikey=unik),
+            tmpfa = temp(expand("TMP/{cenv}/ref.fa", cenv=COUNTENV)),
+            tmpanno = temp(expand("TMP/{cenv}/ref.gtf", cenv=COUNTENV))
+    log:    expand("LOGS/{sets}/{cenv}.idx.log", sets=SETS, cenv=COUNTENV)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('INDEX', "--ref-type spliced+unspliced"),
+            afhome = lambda wildcards, output: os.path.join(os.path.dirname(str(output.idx[0])), "af_home")
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && echo \"Found index, continue with quant\" ; else export ALEVIN_FRY_HOME={params.afhome}; mkdir -p {params.afhome}; {params.mapp} set-paths &>> {log}; zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && {params.mapp} index --fasta {output.tmpfa} --gtf {output.tmpanno} -t {threads} {params.ipara} -o {output.idx} &> {log};fi"
+
+if paired == 'paired' or paired == 'singlecell':
+    rule counting:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                idx = rules.generate_index.output.idx,
+                dummy = rules.generate_index.output.idxfile
+        output: cnts = report("COUNTS/{combo}/{file}/af_quant/alevin/quants_mat.mtx.gz", category="COUNTING"),
+                ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/simpleafquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', "--chemistry 10xv3 --resolution cr-like --expected-ori fw --unfiltered-pl"),
+                mapp = COUNTBIN,
+                afhome = lambda wildcards, input: os.path.join(os.path.dirname(str(input.idx)), "af_home"),
+                quantdir = lambda wildcards, output: os.path.join(str(output.ctsdir), "af_quant")
+        shell: "export ALEVIN_FRY_HOME={params.afhome}; mkdir -p {output.ctsdir}; {params.mapp} quant --index {input.idx}/index --reads1 {input.r1} --reads2 {input.r2} -t {threads} {params.cpara} -o {params.quantdir} &> {log} && gzip -c {params.quantdir}/alevin/quants_mat.mtx > {output.cnts} 2>> {log}"
diff --git a/workflows/spit_DTU.nf b/workflows/spit_DTU.nf
index f02db235..65b8bf3f 100644
--- a/workflows/spit_DTU.nf
+++ b/workflows/spit_DTU.nf
@@ -11,6 +11,7 @@ DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
 IDXPARAMS = get_always('spit_DTU_params_INDEX') ?: ''
 COUNTPARAMS = get_always('spit_DTU_params_COUNT') ?: ''
 DTUPARAMS = get_always('spit_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('spit_DTU_params_TERMINUS') ?: ''
 DTUREPS = get_always('DTUREPS') ?: ''
 DTUCOMP = get_always('DTUCOMP') ?: ''
 DTUCOMPS = get_always('DTUCOMPS') ?: ''
@@ -227,6 +228,32 @@ process collect_spit{
     """
 }
 
+process terminus_collapse{
+    conda "terminus.yaml"
+    container "oras://jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+
+    input:
+    path counts
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+
 workflow DTU{ 
     take: collection
 
@@ -259,7 +286,14 @@ workflow DTU{
     }
 
     prepare_dtu_annotation()
-    run_spit(salmon_quant.out.counts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_spit(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
     create_summary_snippet(run_spit.out.tbls.concat(run_spit.out.figs.concat(run_spit.out.session)).collect())
     collect_spit(run_spit.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
 
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
index 32d9575c..1d09d589 100644
--- a/workflows/spit_DTU.smk
+++ b/workflows/spit_DTU.smk
@@ -7,6 +7,10 @@ comparison = comparable_as_string(config,'DTU')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
 
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
 keydict["REF"] = REFERENCE
 keydict["DECOY"] = DECOY
@@ -97,8 +101,35 @@ else:
         shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
 
 
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+
 rule create_annotation_table:
-    input:  dir  = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config)),
+    input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"

From 2c1246cf28b41e17d955b47ad4e31dfc66841370 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Sat, 4 Jul 2026 16:31:26 +0200
Subject: [PATCH 06/80] test coverage overhaul driven by Claude Fable,
 refactoring duplicated code into extra modules, removed dead code

---
 .github/workflows/python-app.yaml             |   2 +-
 MONSDA/Configurator.py                        |  12 +-
 MONSDA/Deprecated.py                          | 181 ----
 MONSDA/Params.py                              |   6 +-
 MONSDA/RunMONSDA.py                           |  11 +-
 MONSDA/Utils.py                               |   6 +-
 MONSDA/Workflows.py                           | 834 +++--------------
 tests/data/config_DTU_test.json               | 128 +++
 tests/golden/config_DTU/nf/_filelist.txt      |   6 +
 ...lore-picard-star_DTU_dexseq_subconfig.json |  77 ++
 ...imgalore-picard-star_DTU_dexseq_subflow.nf | 296 ++++++
 ...ore-picard-star_DTU_drimseq_subconfig.json |  77 ++
 ...mgalore-picard-star_DTU_drimseq_subflow.nf | 297 ++++++
 ...galore-picard-star_DTU_spit_subconfig.json |  77 ++
 ...trimgalore-picard-star_DTU_spit_subflow.nf | 296 ++++++
 tests/golden/config_DTU/smk/_filelist.txt     |   6 +
 ...lore-picard-star_DTU_dexseq_subconfig.json |  77 ++
 ...galore-picard-star_DTU_dexseq_subsnake.smk | 482 ++++++++++
 ...ore-picard-star_DTU_drimseq_subconfig.json |  77 ++
 ...alore-picard-star_DTU_drimseq_subsnake.smk | 511 +++++++++++
 ...galore-picard-star_DTU_spit_subconfig.json |  77 ++
 ...imgalore-picard-star_DTU_spit_subsnake.smk | 503 +++++++++++
 ...est_fastqc-bbduk-picard-bwa_subconfig.json |  87 ++
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 554 ++++++++++++
 ...st_fastqc-bbduk-picard-star_subconfig.json |  87 ++
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 584 ++++++++++++
 ..._fastqc-cutadapt-picard-bwa_subconfig.json |  87 ++
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 554 ++++++++++++
 ...fastqc-cutadapt-picard-star_subconfig.json |  87 ++
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 584 ++++++++++++
 ...astqc-trimgalore-picard-bwa_subconfig.json |  87 ++
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 549 ++++++++++++
 ...stqc-trimgalore-picard-star_subconfig.json |  87 ++
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 579 ++++++++++++
 tests/golden/config_Test/nf/_filelist.txt     |  12 +
 ...est_fastqc-bbduk-picard-bwa_subconfig.json |  95 ++
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk | 839 +++++++++++++++++
 ...st_fastqc-bbduk-picard-star_subconfig.json |  95 ++
 ...Test_fastqc-bbduk-picard-star_subsnake.smk | 754 ++++++++++++++++
 ..._fastqc-cutadapt-picard-bwa_subconfig.json |  95 ++
 ...st_fastqc-cutadapt-picard-bwa_subsnake.smk | 839 +++++++++++++++++
 ...fastqc-cutadapt-picard-star_subconfig.json |  95 ++
 ...t_fastqc-cutadapt-picard-star_subsnake.smk | 754 ++++++++++++++++
 ...astqc-trimgalore-picard-bwa_subconfig.json |  95 ++
 ..._fastqc-trimgalore-picard-bwa_subsnake.smk | 846 ++++++++++++++++++
 ...stqc-trimgalore-picard-star_subconfig.json |  95 ++
 ...fastqc-trimgalore-picard-star_subsnake.smk | 761 ++++++++++++++++
 tests/golden/config_Test/smk/_filelist.txt    |  12 +
 tests/test_Utils.py                           |  37 +-
 tests/test_Workflows.py                       | 357 ++++++++
 workflows/dexseq_DTU.nf                       | 118 +--
 workflows/dexseq_DTU.smk                      | 109 +--
 workflows/drimseq_DTU.nf                      | 118 +--
 workflows/drimseq_DTU.smk                     | 107 +--
 workflows/dtu_base.nf                         | 117 +++
 workflows/dtu_base.smk                        | 106 +++
 workflows/spit_DTU.nf                         | 118 +--
 workflows/spit_DTU.smk                        | 107 +--
 58 files changed, 13076 insertions(+), 1570 deletions(-)
 delete mode 100644 MONSDA/Deprecated.py
 create mode 100644 tests/data/config_DTU_test.json
 create mode 100644 tests/golden/config_DTU/nf/_filelist.txt
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
 create mode 100644 tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
 create mode 100644 tests/golden/config_DTU/smk/_filelist.txt
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
 create mode 100644 tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/_filelist.txt
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/_filelist.txt
 create mode 100644 tests/test_Workflows.py
 create mode 100644 workflows/dtu_base.nf
 create mode 100644 workflows/dtu_base.smk

diff --git a/.github/workflows/python-app.yaml b/.github/workflows/python-app.yaml
index f1f142ea..33fadca7 100644
--- a/.github/workflows/python-app.yaml
+++ b/.github/workflows/python-app.yaml
@@ -72,7 +72,7 @@ jobs:
       - name: Run unit tests with coverage
         run: |          
           cd ${{ github.workspace }}
-          pytest tests/test_Utils.py -v --cov=MONSDA --cov-report=xml --cov-report=html
+          pytest tests/ -v --cov=MONSDA --cov-report=xml --cov-report=html --cov-fail-under=25
       - name: Upload coverage reports
         uses: codecov/codecov-action@v4
         if: always()
diff --git a/MONSDA/Configurator.py b/MONSDA/Configurator.py
index 97bd7be8..8cb5ec66 100755
--- a/MONSDA/Configurator.py
+++ b/MONSDA/Configurator.py
@@ -27,7 +27,7 @@
     installpath = os.path.dirname(__file__).replace(
         os.sep.join(["lib", pythonversion, "site-packages", "MONSDA"]), "share"
     )
-except:
+except Exception:
     installpath = os.getcwd()
 
 configpath = os.path.join(installpath, "MONSDA", "configs")
@@ -179,7 +179,7 @@ def proof_input(self, whitespace, proof=None, spec=None):
                     [float(x) for x in a.split(",")]
                     self.answer = a
                     break
-                except:
+                except ValueError:
                     self.clear(2)
                     prRed("please enter integer or float")
                     continue
@@ -304,7 +304,7 @@ def setInDict(dataDict, maplist, value):
                 dataDict[first].append(value)
             else:
                 dataDict[first] = value
-        except:
+        except (KeyError, TypeError, AttributeError):
             dataDict[first] = value
 
 
@@ -579,7 +579,7 @@ def show_settings():
             var = json.dumps(var, indent=4)
         try:
             print(f"{name} = {var}")
-        except:
+        except Exception:
             print(f"{name} = NestedDefaultDict()")
     print("\n============")
 
@@ -1140,7 +1140,7 @@ def set_settings():
                 try:
                     if project.samplesDict[k]["cond"] == ":".join(maplist):
                         seq = project.samplesDict[k]["seq"]
-                except:
+                except (KeyError, TypeError):
                     continue
             setInDict(project.settingsDict, maplist + ["SEQUENCING"], seq)
             settings_to_make = ["REFERENCE", "DECOY", "GTF", "GFF"]
@@ -1257,7 +1257,7 @@ def modify(config=None):
             else:
                 print("")
             prCyan(f"   {config}")
-        except:
+        except Exception:
             er = 2
 
         condition_pathes = getPathesFromDict(modify_config, "SAMPLES")
diff --git a/MONSDA/Deprecated.py b/MONSDA/Deprecated.py
deleted file mode 100644
index cd5bd546..00000000
--- a/MONSDA/Deprecated.py
+++ /dev/null
@@ -1,181 +0,0 @@
-########################################
-############## DEPRECATED ##############
-########################################
-
-@check_run
-def sources(config):
-    logid = scriptname+'.Collection_sources: '
-    ret = list()
-    search =  [x[0] for x in keysets_from_dict(config["SOURCE"]) if x[0] != 'last']
-    if len(getFromDict(config['SAMPLES'], search)) > 0:
-        ret.extend(search)
-    log.debug(logid+str(ret))
-    return ret
-
-@check_run
-def genomepath(s, config):
-    logid=scriptname+'.Collection_genomepath: '
-    sa = os.path.basename(str(s))
-    cond= s.split(os.sep)[-2]
-    sk = find_key_for_value(sa, config["SAMPLES"])
-    log.debug(logid+'GENOMEPATH: '+str([sa, cond, sk]))
-    for skey in sk:
-        klist = value_extract(skey, config["SOURCE"])
-        for k in klist:
-            for x, y in config["GENOME"].items():
-                log.debug(logid+'GENOMEPATH: '+str([x, y, k]))
-                if str(k) == str(y) or str(k) == str(x):
-                    return os.path.join(str(x), str(y))
-
-@check_run
-def genome(s, config):
-    logid=scriptname+'.Collection_genome: '
-    sa = os.path.basename(str(s))
-    sp = source_from_sample(str(s), config)
-    cond= s.split(os.sep)[-2]
-    sk = find_key_for_value(sa, config['SAMPLES'])
-    for skey in sk:
-        klist = value_extract(skey, config['SOURCE'])
-        for k in klist:
-            for x, y in config['GENOME'].items():
-                log.debug(logid+str([k, x, y]))
-                if str(k) == str(x):
-                    return str(y)
-
-@check_run
-def fullgenomepath(sa, config):
-    ret=list()
-    for s in sa:
-        l = config["GENOME"][s]
-        ret.append(os.path.join(str(s), str(l)))
-    return ret
-
-@check_run
-def genomename(s, config):
-    s = os.path.basename(str(s))
-    for k, v in config["SAMPLES"].items():
-        for g, l in v.items():
-            if s in l:
-                for x, y in config["GENOME"].items():
-                    if g == y:
-                        return str(x)
-
-@check_run
-def transcriptomepath(s, config):
-    logid=scriptname+'.Collection_transcriptomepath: '
-    sa = os.path.basename(str(s))
-    cond= s.split(os.sep)[-2]
-    sk = find_key_for_value(sa, config["SAMPLES"])
-    log.debug(logid+'TRANSCRIPTOMEPATH: '+str([sa, cond, sk]))
-    for skey in sk:
-        klist = value_extract(skey, config["SOURCE"])
-        for k in klist:
-            for x, y in config["TRANSCRIPTOME"].items():
-                log.debug(logid+'TRANSCRIPTOMEPATH: '+str([x, y, k]))
-                if str(k) == str(y) or str(k) == str(x):
-                    return os.path.join(str(x), str(y))
-
-@check_run
-def transcriptome(s, config):
-    logid=scriptname+'.Collection_transcriptome: '
-    sa = os.path.basename(str(s))
-    sp = source_from_sample(str(s), config)
-    cond= s.split(os.sep)[-2]
-    sk = find_key_for_value(sa, config['SAMPLES'])
-    for skey in sk:
-        klist = value_extract(skey, config['SOURCE'])
-        for k in klist:
-            for x, y in config['TRANSCRIPTOME'].items():
-                log.debug(logid+str([k, x, y]))
-                if str(k) == str(x):
-                    return str(y)
-
-@check_run
-def fulltranscriptomepath(sa, config):
-    ret=list()
-    for s in sa:
-        l = config["TRANSCRIPTOME"][s]
-        ret.append(os.path.join(str(s), str(l)))
-    return ret
-
-@check_run
-def transcriptomename(s, config):
-    s = os.path.basename(str(s))
-    for k, v in config["SAMPLES"].items():
-        for g, l in v.items():
-            if s in l:
-                for x, y in config["TRANSCRIPTOME"].items():
-                    if g == y:
-                        return str(x)
-
-
-@check_run
-def namefromfile(s, config):
-    if 'NAME' not in config:
-        return ''
-    else:
-        sa = os.path.basename(str(s))
-        cond= s.split(os.sep)[-2]
-        sk = find_key_for_value(sa, config["SAMPLES"])
-        for skey in sk:
-            klist = value_extract(skey, config["NAME"])
-            for k in klist:
-                if str(skey) == str(cond):
-                    return str(k)
-
-
-@check_run
-def namefrompath(p, config):
-    p = os.path.dirname(p).split(os.sep)
-    klist = getFromDict(config["NAME"], p) if 'NAME' in config else list('')
-    for k in klist:
-        return str(k)
-
-@check_run
-def pathstogenomes(samples, config):
-    ret = list()
-    for s in samples:
-        s = os.path.basename(s)
-        for k, v in config["SAMPLES"].items():
-            for g, l in v.items():
-                if s in l:
-                    for x, y in config["GENOME"].items():
-                        if g == y:
-                            ret.append(os.path.join(str(x), str(y)))
-    return sorted(list(set(ret)))
-
-
-@check_run
-def source_from_sample(sample, config):
-    logid=scriptname+'.Collection_source_from_sample: '
-    s = os.path.dirname(str(sample))
-    cond= s.split(os.sep)
-    log.debug(logid+str([s, cond]))
-    ret = getFromDict(config["SOURCE"], cond)[0]
-    return ret
-
-
-@check_run
-def anno_from_file(sample, config, step):
-    logid = scriptname+'.Collection_anno_from_file: '
-    p = os.path.dirname(genomepath(sample, config))
-    s = source_from_sample(sample, config)
-    ret = os.path.join(config["REFERENCE"], p, subDict(config["ANNOTATE"], s)[step])
-    log.debug(logid+str(ret))
-    return ret
-
-@check_run
-def anno_from_source(source, config, step):
-    logid = scriptname+'.Collection_anno_from_source: '
-    s = source.split(os.sep)[0:-1]
-    p = s[0]
-    samp = source.split(os.sep)[-1]
-    log.debug(logid+str(s))
-    runstate = runstate_from_sample([samp], config)[0]
-    lst = list()
-    lst.extend(s)
-    lst.append(runstate)
-    log.debug(logid+str(lst))
-    ret = os.path.join(config["REFERENCE"], p, subDict(config["ANNOTATE"], lst)[step])
-    log.debug(logid+str(ret))
-    return ret
diff --git a/MONSDA/Params.py b/MONSDA/Params.py
index 6a62a918..80a71fbb 100644
--- a/MONSDA/Params.py
+++ b/MONSDA/Params.py
@@ -1390,7 +1390,7 @@ def runstate_from_sample(sample: list, config: dict) -> list:
         log.debug(logid + "SAMPLE: " + s)
         try:
             c = mu.get_from_dict(config["SETTINGS"], s.split(os.sep))[0]
-        except:
+        except (KeyError, IndexError, TypeError):
             c = None
         log.debug(logid + "SETTINGS: " + str(c))
         if mu.dict_inst(c):
@@ -1698,7 +1698,7 @@ def get_pairing(
                         log.debug(logid + "Match found: " + str(v) + " : " + str(x))
                         try:
                             matching = samplecond([x], config)[0].replace("MAPPED/", "")
-                        except:
+                        except (KeyError, IndexError):
                             matching = x
                         log.info(logid + "PAIRINGS: " + sample + ": " + str(matching))
         if not matching or matching == "":
@@ -1819,7 +1819,7 @@ def check_tool_params(
             return "std"
         else:
             return ""
-    except:
+    except (KeyError, IndexError, TypeError):
         if subconf == "MAPPING":
             return "std"
         else:
diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index 422c82d3..fc287583 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -147,6 +147,14 @@ def parseargs():
         help="Container registry hostname for ORAS image pulls (default: docker.io). "
              "Use e.g. ghcr.io for GitHub Container Registry.",
     )
+    parser.add_argument(
+        "--oras-namespace",
+        type=str,
+        default="jfallmann/monsda",
+        metavar="NAMESPACE",
+        help="Container namespace/repository for ORAS image pulls "
+             "(default: jfallmann/monsda). Use e.g. myuser/myrepo for a custom registry.",
+    )
 
     if len(sys.argv) == 1:
         parser.print_help(sys.stderr)
@@ -207,7 +215,7 @@ def run_snakemake(
                     os.sep.join(["lib", pythonversion, "site-packages", "MONSDA"]),
                     "share",
                 )
-            except:
+            except Exception:
                 installpath = os.getcwd()
 
             workflowpath = os.path.join(installpath, "MONSDA", "workflows")
@@ -972,6 +980,7 @@ def main():
 
         # --- set ORAS registry for container image pulls ---
         mw.set_oras_registry(knownargs.oras_registry)
+        mw.set_oras_namespace(knownargs.oras_namespace)
 
         log.debug(
             f"{logid} ARGS: {args} {type(args)} KNOWNARGS: {knownargs} {type(knownargs)} OPTIONALARGS: {optionalargs} {type(optionalargs)}"
diff --git a/MONSDA/Utils.py b/MONSDA/Utils.py
index 8dd741f5..a9a93fe6 100644
--- a/MONSDA/Utils.py
+++ b/MONSDA/Utils.py
@@ -411,7 +411,7 @@ def merge_dicts(d:dict, u:dict) -> dict:
     # python 3.8+ compatibility
     try:
         collectionsAbc = collections.abc
-    except:
+    except AttributeError:
         collectionsAbc = collections
 
     for k, v in six.iteritems(u):
@@ -876,7 +876,9 @@ def toarray(file:str, ulim:int) -> np.array:
         usecols=(ulim),
         delimiter="\t",
         unpack=True,
-        converters={ulim: lambda s: convertcol(s.decode("utf-8"))},
+        converters={
+            ulim: lambda s: convertcol(s.decode("utf-8") if isinstance(s, bytes) else s)
+        },
     )
     return x
 
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 8f863430..293206e0 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -45,7 +45,7 @@
     installpath = os.path.dirname(__file__).replace(
         os.sep.join(["lib", pythonversion, "site-packages", "MONSDA"]), "share"
     )
-except:
+except Exception:
     installpath = os.getcwd()
 
 workflowpath = os.path.join(installpath, "MONSDA", "workflows")
@@ -57,6 +57,8 @@
 # Docker Hub namespace like "jfallmann/" without dots before the first slash)
 oraspath = re.compile(r'oras://(?![\w.-]+\.[\w.-]+/)')
 oras_registry = "docker.io"
+oras_default_namespace = "jfallmann/monsda"
+oras_namespace = oras_default_namespace
 
 
 def set_oras_registry(registry: str):
@@ -65,16 +67,53 @@ def set_oras_registry(registry: str):
     oras_registry = registry.strip().rstrip("/")
 
 
+def set_oras_namespace(namespace: str):
+    """Set the ORAS namespace/repository used for container image URIs."""
+    global oras_namespace
+    oras_namespace = namespace.strip().strip("/")
+
+
+def _rewrite_oras(content: str) -> str:
+    """Apply configured ORAS namespace and registry to oras:// URIs."""
+    if oras_namespace != oras_default_namespace:
+        content = content.replace(
+            "oras://" + oras_default_namespace, "oras://" + oras_namespace
+        )
+    return re.sub(oraspath, "oras://" + oras_registry + "/", content)
+
+
 def _fix_oras(line: str) -> str:
     """Insert oras_registry into unqualified oras:// URIs."""
-    return re.sub(oraspath, "oras://" + oras_registry + "/", line)
+    return _rewrite_oras(line)
 
 
 def _write_workflow(filepath, content):
     """Write workflow file with ORAS registry fix applied."""
-    content = re.sub(oraspath, "oras://" + oras_registry + "/", content)
+    content = _rewrite_oras(content)
     write_if_different(filepath, content)
 
+
+def _fill_template(path, loglevel, logfix, condapath, conda_repl, nfmode=False):
+    """Read a workflow template file, strip comments, and apply the standard
+    loglevel/conda/include substitutions. Returns the processed lines as a list."""
+    marker = "include {" if nfmode else "include: "
+    out = list()
+    with open(path, "r") as fh:
+        for line in mu.comment_remover(fh.readlines()):
+            line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
+            line = re.sub(condapath, conda_repl, line)
+            if marker in line:
+                if nfmode:
+                    line = fixinclude(
+                        line, loglevel, condapath, envpath, workflowpath, logfix, "nfmode"
+                    )
+                else:
+                    line = fixinclude(
+                        line, loglevel, condapath, envpath, workflowpath, logfix
+                    )
+            out.append(line)
+    return out
+
 try:
     scriptname = (
         os.path.basename(inspect.stack()[-1].filename)
@@ -298,7 +337,7 @@ def create_subworkflow(config, subwork, conditions, envs=None, stage=None):
     for condition in list(set(conditions)):
         try:
             env = str(mu.sub_dict(config[subwork], condition)[stage + "ENV"])
-        except:
+        except (KeyError, TypeError):
             if "TOOLS" not in config[subwork]:
                 log.error(
                     "No tool environment found for "
@@ -310,7 +349,7 @@ def create_subworkflow(config, subwork, conditions, envs=None, stage=None):
             env = ""
         try:
             exe = str(mu.sub_dict(config[subwork], condition)[stage + "BIN"])
-        except:
+        except (KeyError, TypeError):
             if "TOOLS" not in config[subwork]:
                 log.error(
                     "No tool binary found for "
@@ -494,15 +533,7 @@ def make_pre(
             add = list()
 
             smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda:  "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    add.append(line)
+            add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda:  "' + envpath, nfmode=False))
 
             for i in range(len(worklist)):
                 log.debug(
@@ -579,35 +610,12 @@ def make_pre(
                             subname = toolenv + "_raw.smk"
 
                         smkf = os.path.abspath(os.path.join(workflowpath, subname))
-                        with open(smkf, "r") as smk:
-                            for line in mu.comment_remover(smk.readlines()):
-                                line = re.sub(
-                                    logfix, "loglevel='" + loglevel + "'", line
-                                )
-                                line = re.sub(condapath, 'conda: "' + envpath, line)
-                                if "include: " in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                        subjobs.append("\n\n")
 
                 smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                        line = re.sub(condapath, 'conda: "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line, loglevel, condapath, envpath, workflowpath, logfix
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                subjobs.append("\n\n")
 
                 smko = os.path.abspath(
                     os.path.join(
@@ -645,16 +653,8 @@ def make_pre(
         for condition in conditions:
             add = list()
             smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    add.append(line)
-                add.append("\n\n")
+            add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+            add.append("\n\n")
 
             # Add variable for combination string
             add.append(
@@ -726,28 +726,12 @@ def make_pre(
                 )  # RuleThemAll for snakemake depending on chosen workflows
 
                 smkf = os.path.abspath(os.path.join(workflowpath, subname))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                        line = re.sub(condapath, 'conda: "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line, loglevel, condapath, envpath, workflowpath, logfix
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                subjobs.append("\n\n")
 
                 smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                        line = re.sub(condapath, 'conda: "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line, loglevel, condapath, envpath, workflowpath, logfix
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                subjobs.append("\n\n")
 
                 smko = os.path.abspath(
                     os.path.join(
@@ -815,15 +799,7 @@ def make_sub(
             add = list()
 
             smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    add.append(line)
+            add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
 
             for i in range(len(worklist)):
                 log.debug(
@@ -943,39 +919,15 @@ def make_sub(
                             subconf["PREDEDUP"] = "enabled"
 
                         smkf = os.path.abspath(os.path.join(workflowpath, subname))
-                        with open(smkf, "r") as smk:
-                            for line in mu.comment_remover(smk.readlines()):
-                                line = re.sub(condapath, 'conda: "' + envpath, line)
-                                if "include: " in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                        subjobs.append("\n\n")
 
                 if "MAPPING" in works and envs[works.index("MAPPING")] not in [
                     "piscem"
                 ]:
                     smkf = os.path.abspath(os.path.join(workflowpath, "mapping.smk"))
-                    with open(smkf, "r") as smk:
-                        for line in mu.comment_remover(smk.readlines()):
-                            line = re.sub(condapath, 'conda: "' + envpath, line)
-                            if "include: " in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                    subjobs.append("\n\n")
                 if "QC" in subworkflows:
                     # Use rustqc-specific multiqc whenever rustqc is part of this combo
                     qc_mqc = (
@@ -984,32 +936,13 @@ def make_sub(
                         else "multiqc.smk"
                     )
                     smkf = os.path.abspath(os.path.join(workflowpath, qc_mqc))
-                    with open(smkf, "r") as smk:
-                        for line in mu.comment_remover(smk.readlines()):
-                            line = re.sub(condapath, 'conda: "' + envpath, line)
-                            if "include: " in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                    subjobs.append("\n\n")
 
                 # Append footer and write out subsnake and subconf per condition
                 smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(condapath, 'conda: "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line, loglevel, condapath, envpath, workflowpath, logfix
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                subjobs.append("\n\n")
 
                 smko = os.path.abspath(
                     os.path.join(
@@ -1037,16 +970,8 @@ def make_sub(
             add = list()
 
             smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    add.append(line)
-                add.append("\n\n")
+            add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+            add.append("\n\n")
 
             # Add variable for combination string
             add.append(
@@ -1138,20 +1063,8 @@ def make_sub(
                     )
 
                     smkf = os.path.abspath(os.path.join(workflowpath, subname))
-                    with open(smkf, "r") as smk:
-                        for line in mu.comment_remover(smk.readlines()):
-                            line = re.sub(condapath, 'conda: "' + envpath, line)
-                            if "include: " in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                    subjobs.append("\n\n")
 
             if "MAPPING" in subworkflows:
                 _map_tools, _ = create_subworkflow(config, "MAPPING", [condition])
@@ -1160,15 +1073,8 @@ def make_sub(
                 )
                 if not _skip_postmap:
                     smkf = os.path.abspath(os.path.join(workflowpath, "mapping.smk"))
-                    with open(smkf, "r") as smk:
-                        for line in mu.comment_remover(smk.readlines()):
-                            line = re.sub(condapath, 'conda: "' + envpath, line)
-                            if "include: " in line:
-                                line = fixinclude(
-                                    line, loglevel, condapath, envpath, workflowpath, logfix
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                    subjobs.append("\n\n")
                 if "QC" in subworkflows:
                     # Use rustqc-specific multiqc whenever rustqc is part of this combo
                     _qc_tools, _ = create_subworkflow(config, "QC", [condition])
@@ -1179,32 +1085,12 @@ def make_sub(
                         else "multiqc.smk"
                     )
                     smkf = os.path.abspath(os.path.join(workflowpath, qc_mqc))
-                    with open(smkf, "r") as smk:
-                        for line in mu.comment_remover(smk.readlines()):
-                            line = re.sub(condapath, 'conda: "' + envpath, line)
-                            if "include: " in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+                    subjobs.append("\n\n")
 
             smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    subjobs.append(line)
-                subjobs.append("\n\n")
+            subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+            subjobs.append("\n\n")
 
             smko = os.path.abspath(
                 os.path.join(subdir, "_".join(["_".join(condition), "subsnake.smk"]))
@@ -1260,15 +1146,7 @@ def make_post(
         add = list()
 
         smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-        with open(smkf, "r") as smk:
-            for line in mu.comment_remover(smk.readlines()):
-                line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                line = re.sub(condapath, 'conda: "' + envpath, line)
-                if "include: " in line:
-                    line = fixinclude(
-                        line, loglevel, condapath, envpath, workflowpath, logfix
-                    )
-                add.append(line)
+        add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
 
         for i in range(len(envlist)):
             envs = envlist[i].split("-")
@@ -1372,38 +1250,13 @@ def make_post(
                         os.path.abspath(os.path.join(workflowpath, toolenv))
                         + "_trim.smk"
                     )
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                        line = re.sub(condapath, 'conda:  "' + envpath, line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                            )
-                        subjobs.append(line)
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda:  "' + envpath, nfmode=False))
                 subjobs.append("\n\n")
 
                 # Append footer and write out subsnake and subconf for all conditions
                 smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-                with open(smkf, "r") as smk:
-                    for line in mu.comment_remover(smk.readlines()):
-                        line = re.sub(condapath, 'conda: "../', line)
-                        if "include: " in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "../', nfmode=False))
+                subjobs.append("\n\n")
 
                 te = (
                     toolenv.split("_")[0] if "_" in toolenv else toolenv
@@ -1449,15 +1302,7 @@ def make_post(
         add = list()
         subconf = mu.NestedDefaultDict()
         smkf = os.path.abspath(os.path.join(workflowpath, "header.smk"))
-        with open(smkf, "r") as smk:
-            for line in mu.comment_remover(smk.readlines()):
-                line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                line = re.sub(condapath, 'conda: "' + envpath, line)
-                if "include: " in line:
-                    line = fixinclude(
-                        line, loglevel, condapath, envpath, workflowpath, logfix
-                    )
-                add.append(line)
+        add.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
 
         # Postprocessing runs across all conditions - collect configs from all conditions at once
         listoftools, listofconfigs = create_subworkflow(
@@ -1524,27 +1369,13 @@ def make_post(
                 smkf = (
                     os.path.abspath(os.path.join(workflowpath, toolenv)) + "_trim.smk"
                 )
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    subjobs.append(line)
-                subjobs.append("\n\n")
+            subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+            subjobs.append("\n\n")
 
             # Append footer and write out subsnake and subconf for all conditions
             smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
-            with open(smkf, "r") as smk:
-                for line in mu.comment_remover(smk.readlines()):
-                    line = re.sub(condapath, 'conda: "' + envpath, line)
-                    if "include: " in line:
-                        line = fixinclude(
-                            line, loglevel, condapath, envpath, workflowpath, logfix
-                        )
-                    subjobs.append(line)
-                subjobs.append("\n\n")
+            subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+            subjobs.append("\n\n")
 
             te = (
                 toolenv.split("_")[0] if "_" in toolenv else toolenv
@@ -1630,16 +1461,8 @@ def make_summary(config, subdir, loglevel, combinations=None):
         subjobs.append("\n\n")
 
     smkf = os.path.abspath(os.path.join(workflowpath, "summary.smk"))
-    with open(smkf, "r") as smk:
-        for line in mu.comment_remover(smk.readlines()):
-            line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-            line = re.sub(condapath, 'conda: "' + envpath, line)
-            if "include: " in line:
-                line = fixinclude(
-                    line, loglevel, condapath, envpath, workflowpath, logfix
-                )
-            subjobs.append(line)
-        subjobs.append("\n\n")
+    subjobs.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda: "' + envpath, nfmode=False))
+    subjobs.append("\n\n")
 
     smkf = os.path.abspath(os.path.join(workflowpath, "footer.smk"))
     with open(smkf, "r") as smk:
@@ -1703,15 +1526,7 @@ def rulethemall(subworkflows, config, loglevel, condapath, logfix, combo=""):
         log.debug(logid + "Simulated read trimming only!")
         mu.makeoutdir("TRIMMED_FASTQ")
         smkf = os.path.abspath(os.path.join(workflowpath, "simulatetrim.smk"))
-        with open(smkf, "r") as smk:
-            for line in mu.comment_remover(smk.readlines()):
-                line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                line = re.sub(condapath, 'conda:  "' + envpath, line)
-                if "include: " in line:
-                    line = fixinclude(
-                        line, loglevel, condapath, envpath, workflowpath, logfix
-                    )
-                todos.append(line)
+        todos.extend(_fill_template(smkf, loglevel, logfix, condapath, 'conda:  "' + envpath, nfmode=False))
         todos.append("\n\n")
 
     if (
@@ -1753,7 +1568,7 @@ def fixinclude(
         toinclude = str.split(line)[-1].replace('"', "")
         toinclude = str.join(os.sep, [workflowpath, toinclude])
         with open(toinclude, "r") as incl:
-            for line in incl.readlines():
+            for line in mu.comment_remover(incl.readlines()):
                 line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
                 line = re.sub(condapath, condaline + envpath, line)
                 line = _fix_oras(line)
@@ -2360,94 +2175,7 @@ def nf_tool_params(
 
 @check_run
 def nf_get_processes(config):
-    logid = scriptname + ".Workflows_nf_get_processes: "
-
-    preprocess = subworkflows = postprocess = []
-
-    # Define workflow stages
-    pre = ["QC", "FETCH", "BASECALL"]
-    sub = ["TRIMMING", "MAPPING", "QC", "DEDUP"]
-    post = ["COUNTING", "TRACKS", "PEAKS", "DE", "DEU", "DAS", "DTU", "CIRCS"]
-
-    wfs = [x.replace(" ", "") for x in config["WORKFLOWS"].split(",")]
-
-    if "WORKFLOWS" in config:
-        log.debug(
-            logid
-            + "CONFIG-WORKFLOWS: "
-            + str(wfs)
-            + "\t"
-            + str(pre)
-            + "\t"
-            + str(sub)
-            + "\t"
-            + str(post)
-        )
-        subworkflows = [str(x) for x in wfs if x in sub]
-        log.debug(logid + "Sub: " + str(subworkflows))
-        if len(subworkflows) == 0 or subworkflows[0] == "":
-            subworkflows = []
-        preprocess = [x for x in wfs if x in pre]
-        if len(preprocess) == 0 or preprocess[0] == "":
-            preprocess = None
-        log.debug(
-            logid
-            + "Intermediate-WORKFLOWS: "
-            + str([preprocess, subworkflows, postprocess])
-        )
-
-        if (
-            subworkflows
-            and any(w in subworkflows for w in ["TRIMMING", "MAPPING", "DEDUP"])
-            and preprocess
-            and "QC" in preprocess
-        ):
-            preprocess.remove("QC")
-
-        if (
-            preprocess
-            and "QC" in preprocess
-            and not any(w in subworkflows for w in ["TRIMMING", "MAPPING", "DEDUP"])
-        ):
-            subworkflows.remove("QC")
-
-        postprocess = [x for x in wfs if x in post]
-        if len(postprocess) == 0 or postprocess[0] == "":
-            postprocess = []
-    else:
-        log.error("NO WORKFLOWS DEFINED, NOTHING TO DO!")
-        sys.exit()
-
-    if preprocess:
-        try:
-            all([config[x] or x == "" for x in preprocess])
-        except KeyError:
-            log.warning(
-                logid
-                + "Not all required preprocessing steps have configuration in the config file"
-            )
-
-    if subworkflows:
-        try:
-            all([config[x] or x == "TRIMMING" or x == "" for x in subworkflows])
-        except KeyError:
-            log.warning(
-                logid
-                + "Not all required subworkflows have configuration in the config file"
-            )
-
-    if postprocess:
-        try:
-            all([config[x] or x == "" for x in postprocess])
-        except KeyError:
-            log.warning(
-                logid
-                + "Not all required postprocessing steps have configuration in the config file"
-            )
-
-    log.debug(logid + "WORKFLOWS: " + str([preprocess, subworkflows, postprocess]))
-
-    return [preprocess, subworkflows, postprocess]
+    return get_processes(config)
 
 
 @check_run
@@ -2484,22 +2212,8 @@ def nf_make_pre(
             add = list()
 
             nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-            with open(nfi, "r") as nf:
-                for line in mu.comment_remover(nf.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda "' + envpath, line)
-                    if "include {" in line:
-                        line = fixinclude(
-                            line,
-                            loglevel,
-                            condapath,
-                            envpath,
-                            workflowpath,
-                            logfix,
-                            "nfmode",
-                        )
-                    add.append(line)
-                add.append("\n\n")
+            add.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+            add.append("\n\n")
 
             for i in range(len(worklist)):
                 log.debug(
@@ -2572,47 +2286,15 @@ def nf_make_pre(
                             flowlist.append("MULTIQC")
 
                         nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                        with open(nfi, "r") as nf:
-                            for line in mu.comment_remover(nf.readlines()):
-                                line = re.sub(
-                                    logfix, "loglevel='" + loglevel + "'", line
-                                )
-                                line = re.sub(condapath, 'conda "' + envpath, line)
-                                if "include {" in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                        "nfmode",
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                        subjobs.append("\n\n")
 
                         if works[j] == "QC":
                             nfi = os.path.abspath(
                                 os.path.join(workflowpath, "multiqc.nf")
                             )
-                            with open(nfi, "r") as nf:
-                                for line in mu.comment_remover(nf.readlines()):
-                                    line = re.sub(
-                                        logfix, "loglevel='" + loglevel + "'", line
-                                    )
-                                    line = re.sub(condapath, 'conda "' + envpath, line)
-                                    if "include {" in line:
-                                        line = fixinclude(
-                                            line,
-                                            loglevel,
-                                            condapath,
-                                            envpath,
-                                            workflowpath,
-                                            logfix,
-                                            "nfmode",
-                                        )
-                                    subjobs.append(line)
-                                subjobs.append("\n\n")
+                            subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                            subjobs.append("\n\n")
 
                         # workflow merger
                         subjobs.append("\n\n" + "workflow {\n")
@@ -2689,22 +2371,8 @@ def nf_make_pre(
             log.debug(logid + "PREPARING " + str(subwork) + " " + str(condition))
 
             nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-            with open(nfi, "r") as nf:
-                for line in mu.comment_remover(nf.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda "' + envpath, line)
-                    if "include {" in line:
-                        line = fixinclude(
-                            line,
-                            loglevel,
-                            condapath,
-                            envpath,
-                            workflowpath,
-                            logfix,
-                            "nfmode",
-                        )
-                    subjobs.append(line)
-                subjobs.append("\n\n")
+            subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+            subjobs.append("\n\n")
 
             listoftools, listofconfigs = create_subworkflow(
                 config, subwork, [condition]
@@ -2775,21 +2443,8 @@ def nf_make_pre(
                     flowlist.append("BASECALL")
 
                 nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                with open(nfi, "r") as nf:
-                    for line in mu.comment_remover(nf.readlines()):
-                        line = re.sub(condapath, 'conda "' + envpath, line)
-                        if "include {" in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                                "nfmode",
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                subjobs.append("\n\n")
 
                 if "DEDUP" in works:
                     flowlist.append("DEDUPBAM")
@@ -2809,21 +2464,8 @@ def nf_make_pre(
                 if subwork == "QC":
                     flowlist.append("MULTIQC")
                     nfi = os.path.abspath(os.path.join(workflowpath, "multiqc.nf"))
-                    with open(nfi, "r") as nf:
-                        for line in mu.comment_remover(nf.readlines()):
-                            line = re.sub(condapath, 'conda "' + envpath, line)
-                            if "include {" in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                    "nfmode",
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                    subjobs.append("\n\n")
 
                 # workflow merger
                 log.debug("FLOWLIST: " + str(flowlist))
@@ -2906,22 +2548,8 @@ def nf_make_sub(
             add = list()
 
             nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-            with open(nfi, "r") as nf:
-                for line in mu.comment_remover(nf.readlines()):
-                    line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                    line = re.sub(condapath, 'conda "' + envpath, line)
-                    if "include {" in line:
-                        line = fixinclude(
-                            line,
-                            loglevel,
-                            condapath,
-                            envpath,
-                            workflowpath,
-                            logfix,
-                            "nfmode",
-                        )
-                    add.append(line)
-                add.append("\n\n")
+            add.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+            add.append("\n\n")
 
             for i in range(len(worklist)):
                 log.debug(
@@ -3052,21 +2680,8 @@ def nf_make_sub(
                             subname = toolenv + "_dedup.nf"
 
                         nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                        with open(nfi, "r") as nf:
-                            for line in mu.comment_remover(nf.readlines()):
-                                line = re.sub(condapath, 'conda "' + envpath, line)
-                                if "include {" in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                        "nfmode",
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                        subjobs.append("\n\n")
 
                         tp.append(
                             nf_tool_params(
@@ -3095,41 +2710,15 @@ def nf_make_sub(
                                 "simulatetrim.nf",
                             )
                         )
-                        with open(nfi, "r") as nf:
-                            for line in mu.comment_remover(nf.readlines()):
-                                line = re.sub(condapath, 'conda "' + envpath, line)
-                                if "include {" in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                        "nfmode",
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                        subjobs.append("\n\n")
 
                     flowlist.append("MAPPING")
 
                     maprad = envs[works.index("MAPPING")] in ["piscem"]
                     nfi = os.path.abspath(os.path.join(workflowpath, "mapping.nf"))
-                    with open(nfi, "r") as nf:
-                        for line in mu.comment_remover(nf.readlines()):
-                            line = re.sub(condapath, 'conda "' + envpath, line)
-                            if "include {" in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                    "nfmode",
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                    subjobs.append("\n\n")
 
                     if "DEDUP" in works:
                         flowlist.append("DEDUPBAM")
@@ -3145,21 +2734,8 @@ def nf_make_sub(
                         else "multiqc.nf"
                     )
                     nfi = os.path.abspath(os.path.join(workflowpath, _mqc_nf))
-                    with open(nfi, "r") as nf:
-                        for line in mu.comment_remover(nf.readlines()):
-                            line = re.sub(condapath, 'conda "' + envpath, line)
-                            if "include {" in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                    "nfmode",
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                    subjobs.append("\n\n")
 
                 # workflow merger
                 log.debug("FLOWLIST: " + str(flowlist))
@@ -3432,39 +3008,13 @@ def nf_make_sub(
                             flowlist.append("QC_DEDUP")
                         subname = toolenv + ".nf"
                         nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                        with open(nfi, "r") as nf:
-                            for line in mu.comment_remover(nf.readlines()):
-                                line = re.sub(condapath, 'conda "' + envpath, line)
-                                if "include {" in line:
-                                    line = fixinclude(
-                                        line,
-                                        loglevel,
-                                        condapath,
-                                        envpath,
-                                        workflowpath,
-                                        logfix,
-                                        "nfmode",
-                                    )
-                                subjobs.append(line)
-                            subjobs.append("\n\n")
+                        subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                        subjobs.append("\n\n")
                         subname = toolenv + "_dedup.nf"
 
                     nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                    with open(nfi, "r") as nf:
-                        for line in mu.comment_remover(nf.readlines()):
-                            line = re.sub(condapath, 'conda "' + envpath, line)
-                            if "include {" in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                    "nfmode",
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                    subjobs.append("\n\n")
 
                     tp.append(
                         nf_tool_params(
@@ -3490,39 +3040,13 @@ def nf_make_sub(
                     log.debug(logid + "Simulated read trimming only!")
                     flowlist.append("TRIMMING")
                     nfi = os.path.abspath(os.path.join(workflowpath, "simulatetrim.nf"))
-                    with open(nfi, "r") as nf:
-                        for line in mu.comment_remover(nf.readlines()):
-                            line = re.sub(condapath, 'conda "' + envpath, line)
-                            if "include {" in line:
-                                line = fixinclude(
-                                    line,
-                                    loglevel,
-                                    condapath,
-                                    envpath,
-                                    workflowpath,
-                                    logfix,
-                                    "nfmode",
-                                )
-                            subjobs.append(line)
-                        subjobs.append("\n\n")
+                    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                    subjobs.append("\n\n")
                 flowlist.append("MAPPING")
 
                 nfi = os.path.abspath(os.path.join(workflowpath, "mapping.nf"))
-                with open(nfi, "r") as nf:
-                    for line in mu.comment_remover(nf.readlines()):
-                        line = re.sub(condapath, 'conda "' + envpath, line)
-                        if "include {" in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                                "nfmode",
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                subjobs.append("\n\n")
 
             if "QC" in subworkflows:
                 flowlist.append("MULTIQC")
@@ -3535,21 +3059,8 @@ def nf_make_sub(
                     else "multiqc.nf"
                 )
                 nfi = os.path.abspath(os.path.join(workflowpath, _mqc_nf))
-                with open(nfi, "r") as nf:
-                    for line in mu.comment_remover(nf.readlines()):
-                        line = re.sub(condapath, 'conda "' + envpath, line)
-                        if "include {" in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                                "nfmode",
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                subjobs.append("\n\n")
 
             # workflow merger
             log.debug("FLOWLIST: " + str(flowlist))
@@ -3740,22 +3251,8 @@ def nf_make_post(
         add = list()
 
         nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-        with open(nfi, "r") as nf:
-            for line in mu.comment_remover(nf.readlines()):
-                line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                line = re.sub(condapath, 'conda "' + envpath, line)
-                if "include {" in line:
-                    line = fixinclude(
-                        line,
-                        loglevel,
-                        condapath,
-                        envpath,
-                        workflowpath,
-                        logfix,
-                        "nfmode",
-                    )
-                add.append(line)
-            add.append("\n\n")
+        add.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+        add.append("\n\n")
 
         for i in range(len(envlist)):
             envs = envlist[i].split("-")
@@ -3833,21 +3330,8 @@ def nf_make_post(
 
                 subname = toolenv + ".nf"
                 nfi = os.path.abspath(os.path.join(workflowpath, subname))
-                with open(nfi, "r") as nf:
-                    for line in mu.comment_remover(nf.readlines()):
-                        line = re.sub(condapath, 'conda "' + envpath, line)
-                        if "include {" in line:
-                            line = fixinclude(
-                                line,
-                                loglevel,
-                                condapath,
-                                envpath,
-                                workflowpath,
-                                logfix,
-                                "nfmode",
-                            )
-                        subjobs.append(line)
-                    subjobs.append("\n\n")
+                subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+                subjobs.append("\n\n")
 
                 tp.append(
                     nf_tool_params(
@@ -3923,22 +3407,8 @@ def nf_make_post(
         subwork = postworkflow
         add = list()
         nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-        with open(nfi, "r") as nf:
-            for line in mu.comment_remover(nf.readlines()):
-                line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-                line = re.sub(condapath, 'conda "' + envpath, line)
-                if "include {" in line:
-                    line = fixinclude(
-                        line,
-                        loglevel,
-                        condapath,
-                        envpath,
-                        workflowpath,
-                        logfix,
-                        "nfmode",
-                    )
-                add.append(line)
-            add.append("\n\n")
+        add.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+        add.append("\n\n")
 
         # Postprocessing runs across all conditions - collect configs from all conditions at once
         flowlist = list()
@@ -3980,21 +3450,8 @@ def nf_make_post(
             subconf.update(sconf)
             subname = toolenv + ".nf"
             nfi = os.path.abspath(os.path.join(workflowpath, subname))
-            with open(nfi, "r") as nf:
-                for line in mu.comment_remover(nf.readlines()):
-                    line = re.sub(condapath, 'conda "' + envpath, line)
-                    if "include {" in line:
-                        line = fixinclude(
-                            line,
-                            loglevel,
-                            condapath,
-                            envpath,
-                            workflowpath,
-                            logfix,
-                            "nfmode",
-                        )
-                    subjobs.append(line)
-                subjobs.append("\n\n")
+            subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+            subjobs.append("\n\n")
 
             tp.append(
                 nf_tool_params(
@@ -4124,39 +3581,12 @@ def nf_make_summary(config, subdir, loglevel, combinations=None):
     subjobs = list()
 
     nfi = os.path.abspath(os.path.join(workflowpath, "header.nf"))
-    with open(nfi, "r") as nf:
-        for line in mu.comment_remover(nf.readlines()):
-            line = re.sub(logfix, "loglevel='" + loglevel + "'", line)
-            line = re.sub(condapath, 'conda "' + envpath, line)
-            if "include {" in line:
-                line = fixinclude(
-                    line,
-                    loglevel,
-                    condapath,
-                    envpath,
-                    workflowpath,
-                    logfix,
-                    "nfmode",
-                )
-            subjobs.append(line)
-        subjobs.append("\n\n")
+    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+    subjobs.append("\n\n")
 
     nfi = os.path.abspath(os.path.join(workflowpath, "summary.nf"))
-    with open(nfi, "r") as nf:
-        for line in mu.comment_remover(nf.readlines()):
-            line = re.sub(condapath, 'conda "' + envpath, line)
-            if "include {" in line:
-                line = fixinclude(
-                    line,
-                    loglevel,
-                    condapath,
-                    envpath,
-                    workflowpath,
-                    logfix,
-                    "nfmode",
-                )
-            subjobs.append(line)
-        subjobs.append("\n\n")
+    subjobs.extend(_fill_template(nfi, loglevel, logfix, condapath, 'conda "' + envpath, nfmode=True))
+    subjobs.append("\n\n")
 
     nfo = os.path.abspath(os.path.join(subdir, "summary_subflow.nf"))
     _write_workflow(nfo, "".join(subjobs))
diff --git a/tests/data/config_DTU_test.json b/tests/data/config_DTU_test.json
new file mode 100644
index 00000000..6852e250
--- /dev/null
+++ b/tests/data/config_DTU_test.json
@@ -0,0 +1,128 @@
+{
+    "WORKFLOWS": "QC,TRIMMING,DEDUP,MAPPING,DTU",
+    "BINS": "",
+    "MAXTHREADS": "4",
+    "VERSION": "FIXME",
+    "SETTINGS": {
+        "Test": {
+            "SAMPLES": [
+                "SRR6357070",
+                "SRR6357071",
+                "SRR6357072"
+            ],
+            "SEQUENCING": "paired",
+            "REFERENCE": "GENOME/genome.fa.gz",
+            "DECOY": "",
+            "ANNOTATION": {
+                "GTF": "GENOME/genomic.gtf.gz",
+                "GFF": "GENOME/genomic.gff.gz"
+            },
+            "IP": "",
+            "GROUPS": [
+                "T1",
+                "T2",
+                "T3"
+            ],
+            "TYPES": "",
+            "BATCHES": "",
+            "INDEX": "",
+            "PREFIX": ""
+        }
+    },
+    "QC": {
+        "TOOLS": {
+            "fastqc": "fastqc"
+        },
+        "Test": {
+            "fastqc": {
+                "OPTIONS": {
+                    "QC": "",
+                    "MULTI": ""
+                }
+            }
+        }
+    },
+    "TRIMMING": {
+        "TOOLS": {
+            "trimgalore": "trim_galore"
+        },
+        "Test": {
+            "trimgalore": {
+                "OPTIONS": {
+                    "TRIM": "--length 8"
+                }
+            }
+        }
+    },
+    "DEDUP": {
+        "TOOLS": {
+            "picard": "picard"
+        },
+        "Test": {
+            "picard": {
+                "OPTIONS": {
+                    "DEDUP": ""
+                }
+            }
+        }
+    },
+    "MAPPING": {
+        "TOOLS": {
+            "star": "STAR"
+        },
+        "Test": {
+            "star": {
+                "OPTIONS": {
+                    "INDEX": "",
+                    "MAP": "--outSAMprimaryFlag AllBestScore",
+                    "EXTENSION": ""
+                }
+            }
+        }
+    },
+    "DTU": {
+        "TOOLS": {
+            "drimseq": "Analysis/DTU/DRIMSEQ.R",
+            "dexseq": "Analysis/DTU/DEXSEQ.R",
+            "spit": "Analysis/DTU/SPIT.py"
+        },
+        "CUTOFFS": {
+            "pvalue": "0.05",
+            "lfc": "1.5"
+        },
+        "COMPARABLE": {
+            "T1-VS-T2": [
+                [
+                    "T1"
+                ],
+                [
+                    "T2"
+                ]
+            ]
+        },
+        "EXCLUDE": [],
+        "Test": {
+            "drimseq": {
+                "OPTIONS": {
+                    "INDEX": "-d GENOMES/transcripts.fa.gz",
+                    "QUANT": "--seqBias --gcBias",
+                    "DTU": ""
+                }
+            },
+            "dexseq": {
+                "OPTIONS": {
+                    "INDEX": "-d GENOMES/transcripts.fa.gz",
+                    "QUANT": "--seqBias --gcBias",
+                    "DTU": ""
+                }
+            },
+            "spit": {
+                "OPTIONS": {
+                    "INDEX": "-d GENOMES/transcripts.fa.gz",
+                    "QUANT": "--seqBias --gcBias",
+                    "DTU": ""
+                }
+            }
+        }
+    }
+}
diff --git a/tests/golden/config_DTU/nf/_filelist.txt b/tests/golden/config_DTU/nf/_filelist.txt
new file mode 100644
index 00000000..985d7e01
--- /dev/null
+++ b/tests/golden/config_DTU/nf/_filelist.txt
@@ -0,0 +1,6 @@
+allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
new file mode 100644
index 00000000..7fa2c131
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/DEXSEQ.R",
+  "DTUENV": "dexseq_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
new file mode 100644
index 00000000..bc3b92bd
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -0,0 +1,296 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+BINS = get_always('BINS')
+DTUENV = get_always('DTUENV')
+DTUBIN = get_always('DTUBIN')
+DTUREF = get_always('DTUREF')
+DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+DTUANNO = get_always('DTUANNO')
+DTUDECOY = get_always('DTUDECOY')
+DTUIDX = get_always('DTUIDX')
+DTUUIDX = get_always('DTUUIDX')
+DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+IDXPARAMS = get_always('dexseq_DTU_params_INDEX') ?: ''
+COUNTPARAMS = get_always('dexseq_DTU_params_COUNT') ?: ''
+DTUPARAMS = get_always('dexseq_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('dexseq_DTU_params_TERMINUS') ?: ''
+DTUREPS = get_always('DTUREPS') ?: ''
+DTUCOMP = get_always('DTUCOMP') ?: ''
+DTUCOMPS = get_always('DTUCOMPS') ?: ''
+PVAL = get_always('DTUPVAL') ?: ''
+LFC = get_always('DTULFC') ?: ''
+PCOMBO = get_always('COMBO') ?: 'none'
+COUNTBIN = 'salmon'
+COUNTENV = 'salmon'
+process salmon_quant{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+    }
+    input:
+    path reads
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        r1 = rs[0]
+        r2 = rs[1]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+process create_summary_snippet{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+    }
+    input:
+    path de
+    output:
+    path "*.Rmd", emit: snps
+    path "log", emit: log
+    script:
+    inlist = de.toString()
+    """
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    """
+}
+process terminus_collapse{
+    conda "<REPO>/envs/terminus.yaml"
+    container "oras://docker.io/jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+    input:
+    path counts
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+process salmon_idx{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/dexseq_index.log"
+        else if (filename == "dexseq.idx")            "$DTUIDX"
+        else                                          "$DTUUIDX"
+    }
+    input:
+    path genome
+    output:
+     path "$DTUUIDXNAME", emit: idx
+    path "*.log", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:    
+    gen =  genome.getName()
+    if (DTUDECOY){
+        decoy = "-d "+"${DTUDECOY}" 
+    }else{
+        decoy = ''
+    }
+    """
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME dexseq.idx
+    """
+}
+process prepare_dtu_annotation{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_dexseq_annotation.log"
+    }
+    output:
+    path "*.gz", emit: anno
+    path "*.log", emit: log
+    script:     
+    ca = COMBO+"_ANNOTATION.gz"
+    ol = "create_DTU_table.log"
+    """
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    """
+}
+process run_dexseq{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/DEXSeqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_dexseq.log"
+    }
+    input:path counts
+    path anno
+    path ref
+    output:
+    path "*_table*", emit: tbls
+    path "*_figure*", emit: figs, optional:true
+    path "*.html", emit: html, optional:true
+    path "*SESSION.gz", emit: session
+    path "log", emit: log
+    script:    
+    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
+    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
+    comp = "${DTUCOMP}".split(':')[0]
+    dparams = "'${DTUPARAMS}'"
+    """
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    """
+}
+process collect_dexseq{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    input:
+    path de
+    script:
+    """
+    echo "$de DONE"
+    """
+}
+workflow DTU{ 
+    take: collection
+    main:
+    TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+        }
+    trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
+    annofile = Channel.fromPath(DTUANNO)
+    checkidx = file(DTUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(DTUUIDX)
+        if (PAIRED == 'paired'){
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
+        }        
+    }
+    else{
+        genomefile = Channel.fromPath(DTUREF)
+        salmon_idx(genomefile)
+        if (PAIRED == 'paired'){
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
+        }
+    }
+    prepare_dtu_annotation()
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_dexseq(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    create_summary_snippet(run_dexseq.out.tbls.concat(run_dexseq.out.figs.concat(run_dexseq.out.session)).collect())
+    collect_dexseq(run_dexseq.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
+    emit:
+    tbls = run_dexseq.out.tbls
+    figs = run_dexseq.out.figs
+    snps = create_summary_snippet.out.snps
+}
+
+
+
+workflow {
+    DTU(dummy)
+}
+
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
new file mode 100644
index 00000000..86f58007
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/DRIMSEQ.R",
+  "DTUENV": "drimseq_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
new file mode 100644
index 00000000..0e6684ea
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -0,0 +1,297 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+BINS = get_always('BINS')
+DTUENV = get_always('DTUENV')
+DTUBIN = get_always('DTUBIN')
+DTUREF = get_always('DTUREF')
+DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+DTUANNO = get_always('DTUANNO')
+DTUDECOY = get_always('DTUDECOY')
+DTUIDX = get_always('DTUIDX')
+DTUUIDX = get_always('DTUUIDX')
+DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+IDXPARAMS = get_always('drimseq_DTU_params_INDEX') ?: ''
+COUNTPARAMS = get_always('drimseq_DTU_params_COUNT') ?: ''
+DTUPARAMS = get_always('drimseq_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('drimseq_DTU_params_TERMINUS') ?: ''
+DTUREPS = get_always('DTUREPS') ?: ''
+DTUCOMP = get_always('DTUCOMP') ?: ''
+DTUCOMPS = get_always('DTUCOMPS') ?: ''
+PVAL = get_always('DTUPVAL') ?: ''
+LFC = get_always('DTULFC') ?: ''
+PCOMBO = get_always('COMBO') ?: 'none'
+COUNTBIN = 'salmon'
+COUNTENV = 'salmon'
+process salmon_quant{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+    }
+    input:
+    path reads
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        r1 = rs[0]
+        r2 = rs[1]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+process create_summary_snippet{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+    }
+    input:
+    path de
+    output:
+    path "*.Rmd", emit: snps
+    path "log", emit: log
+    script:
+    inlist = de.toString()
+    """
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    """
+}
+process terminus_collapse{
+    conda "<REPO>/envs/terminus.yaml"
+    container "oras://docker.io/jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+    input:
+    path counts
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+process salmon_idx{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/drimseq_index.log"
+        else if (filename == "drimseq.idx")           "$DTUIDX"
+        else                                          "$DTUUIDX"
+    }
+    input:
+    path genome
+    output:
+     path "$DTUUIDXNAME", emit: idx
+    path "*.log", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:    
+    gen =  genome.getName()
+    if (DTUDECOY){
+        decoy = "-d "+"${DTUDECOY}" 
+    }else{
+        decoy = ''
+    }
+    """
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME drimseq.idx
+    """
+}
+process prepare_dtu_annotation{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_drimseq_annotation.log"
+    }
+    output:
+    path "*.gz", emit: anno
+    path "*.log", emit: log
+    script:     
+    ca = COMBO+"_ANNOTATION.gz"
+    ol = "create_DTU_table.log"
+    """
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    """
+}
+process run_drimseq{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/drimseqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_drimseq.log"
+    }
+    input:
+    path counts
+    path anno
+    path ref
+    output:
+    path "*_table*", emit: tbls
+    path "*_figure*", emit: figs, optional:true
+    path "*.html", emit: html, optional:true
+    path "*SESSION.gz", emit: session
+    path "log", emit: log
+    script:    
+    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
+    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
+    comp = "${DTUCOMP}".split(':')[0]
+    dparams = "'${DTUPARAMS}'"
+    """
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    """
+}
+process collect_drimseq{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    input:
+    path de
+    script:
+    """
+    echo "$de DONE"
+    """
+}
+workflow DTU{ 
+    take: collection
+    main:
+    TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+        }
+    trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
+    annofile = Channel.fromPath(DTUANNO)
+    checkidx = file(DTUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(DTUUIDX)
+        if (PAIRED == 'paired'){
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
+        }        
+    }
+    else{
+        genomefile = Channel.fromPath(DTUREF)
+        salmon_idx(genomefile)
+        if (PAIRED == 'paired'){
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
+        }
+    }
+    prepare_dtu_annotation()
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_drimseq(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    create_summary_snippet(run_drimseq.out.tbls.concat(run_drimseq.out.figs.concat(run_drimseq.out.session)).collect())
+    collect_drimseq(run_drimseq.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
+    emit:
+    tbls = run_drimseq.out.tbls
+    figs = run_drimseq.out.figs
+    snps = create_summary_snippet.out.snps
+}
+
+
+
+workflow {
+    DTU(dummy)
+}
+
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
new file mode 100644
index 00000000..db11a2f9
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/SPIT.py",
+  "DTUENV": "spit_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
new file mode 100644
index 00000000..a68c9776
--- /dev/null
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -0,0 +1,296 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+BINS = get_always('BINS')
+DTUENV = get_always('DTUENV')
+DTUBIN = get_always('DTUBIN')
+DTUREF = get_always('DTUREF')
+DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+DTUANNO = get_always('DTUANNO')
+DTUDECOY = get_always('DTUDECOY')
+DTUIDX = get_always('DTUIDX')
+DTUUIDX = get_always('DTUUIDX')
+DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+IDXPARAMS = get_always('spit_DTU_params_INDEX') ?: ''
+COUNTPARAMS = get_always('spit_DTU_params_COUNT') ?: ''
+DTUPARAMS = get_always('spit_DTU_params_DTU') ?: ''
+RUNTERMINUS = get_always('spit_DTU_params_TERMINUS') ?: ''
+DTUREPS = get_always('DTUREPS') ?: ''
+DTUCOMP = get_always('DTUCOMP') ?: ''
+DTUCOMPS = get_always('DTUCOMPS') ?: ''
+PVAL = get_always('DTUPVAL') ?: ''
+LFC = get_always('DTULFC') ?: ''
+PCOMBO = get_always('COMBO') ?: 'none'
+COUNTBIN = 'salmon'
+COUNTENV = 'salmon'
+process salmon_quant{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+    }
+    input:
+    path reads
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        r1 = rs[0]
+        r2 = rs[1]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+process create_summary_snippet{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+    }
+    input:
+    path de
+    output:
+    path "*.Rmd", emit: snps
+    path "log", emit: log
+    script:
+    inlist = de.toString()
+    """
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    """
+}
+process terminus_collapse{
+    conda "<REPO>/envs/terminus.yaml"
+    container "oras://docker.io/jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+    input:
+    path counts
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
+process salmon_idx{
+    conda "<REPO>/envs/$COUNTENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/spit_index.log"
+        else if (filename == "spit.idx")           "$DTUIDX"
+        else                                          "$DTUUIDX"
+    }
+    input:
+    path genome
+    output:
+     path "$DTUUIDXNAME", emit: idx
+    path "*.log", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:    
+    gen =  genome.getName()
+    if (DTUDECOY){
+        decoy = "-d "+"${DTUDECOY}" 
+    }else{
+        decoy = ''
+    }
+    """
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME spit.idx
+    """
+}
+process prepare_dtu_annotation{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_spit_annotation.log"
+    }
+    output:
+    path "*.gz", emit: anno
+    path "*.log", emit: log
+    script:     
+    ca = COMBO+"_ANNOTATION.gz"
+    ol = "create_DTU_table.log"
+    """
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    """
+}
+process run_spit{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_spit.log"
+    }
+    input:
+    path counts
+    path anno
+    path ref
+    output:
+    path "*_table*", emit: tbls
+    path "*_figure*", emit: figs, optional:true
+    path "*SESSION.gz", emit: session
+    path "log", emit: log
+    script:    
+    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
+    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
+    comp = "${DTUCOMP}".split(':')[0]
+    dparams = "'${DTUPARAMS}'"
+    """
+    mkdir -p Figures Tables
+    python3 $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    """
+}
+process collect_spit{
+    conda "<REPO>/envs/$DTUENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    input:
+    path de
+    script:
+    """
+    echo "$de DONE"
+    """
+}
+workflow DTU{ 
+    take: collection
+    main:
+    TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+        }
+    trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
+    annofile = Channel.fromPath(DTUANNO)
+    checkidx = file(DTUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(DTUUIDX)
+        if (PAIRED == 'paired'){
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
+        }        
+    }
+    else{
+        genomefile = Channel.fromPath(DTUREF)
+        salmon_idx(genomefile)
+        if (PAIRED == 'paired'){
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
+        } else{
+            salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
+        }
+    }
+    prepare_dtu_annotation()
+    if (RUNTERMINUS?.length() > 0){
+        terminus_collapse(salmon_quant.out.counts.collect())
+        dtucounts = terminus_collapse.out.counts
+    }
+    else{
+        dtucounts = salmon_quant.out.counts
+    }
+    run_spit(dtucounts.collect(), prepare_dtu_annotation.out.anno, annofile)
+    create_summary_snippet(run_spit.out.tbls.concat(run_spit.out.figs.concat(run_spit.out.session)).collect())
+    collect_spit(run_spit.out.tbls.collect().concat(create_summary_snippet.out.snps.collect()))
+    emit:
+    tbls = run_spit.out.tbls
+    figs = run_spit.out.figs
+    snps = create_summary_snippet.out.snps
+}
+
+
+
+
+workflow {
+    DTU(dummy)
+}
+
diff --git a/tests/golden/config_DTU/smk/_filelist.txt b/tests/golden/config_DTU/smk/_filelist.txt
new file mode 100644
index 00000000..69709e2e
--- /dev/null
+++ b/tests/golden/config_DTU/smk/_filelist.txt
@@ -0,0 +1,6 @@
+allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
new file mode 100644
index 00000000..7fa2c131
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/DEXSEQ.R",
+  "DTUENV": "dexseq_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
new file mode 100644
index 00000000..acaeaab8
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -0,0 +1,482 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-star/dexseq_DTU'
+
+scombo = 'fastqc-trimgalore-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    scombo = scombo,
+    read = "R1|R2",
+    type = "sorted|sorted_unique" if not rundedup else "sorted|sorted_unique|sorted_dedup|sorted_unique_dedup"
+
+logid = 'dexseq_DTU.smk '
+DTUBIN, DTUENV = env_bin_from_config(config,'DTU')
+log.debug(logid+"DTUENV: "+str(DTUENV))
+COUNTBIN, COUNTENV = ['salmon','salmon'] #env_bin_from_config(config,'COUNTING') ##PINNING subreads package to version 1.6.4 due to changes in 2.0.1 gene_id length cutoff that interfers
+comparison = comparable_as_string(config,'DTU')
+compstr = [i.split(":")[0] for i in comparison.split(",")]
+usededup = config.get('RUNDEDUP', False)
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = DTUENV
+unik = get_dict_hash(keydict)
+rule themall:
+    input:  session = expand("DTU/{combo}/DTU_DEXSEQ_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
+            res     = expand("DTU/{combo}/Tables/DTU_DEXSEQ_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, scombo=scombo, comparison=compstr),
+            # sig     = expand("DTU/{combo}/Tables/Sig_DTU_DEXSEQ_{scombo}_{comparison}_results.tsv.gz", combo=combo, scombo=scombo, comparison=compstr),
+            # sig_d   = expand("DTU/{combo}/Tables/SigDOWN_DTU_DEXSEQ_{scombo}_{comparison}_results.tsv.gz", combo=combo, scombo=scombo, comparison=compstr),
+            # sig_u   = expand("DTU/{combo}/Tables/SigUP_DTU_DEXSEQ_{scombo}_{comparison}_results.tsv.gz", combo=combo, scombo=scombo, comparison=compstr),
+            Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+rule salmon_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+if paired == 'paired':
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
+                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
+        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
+else:
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
+        shell:  "ln -s {params.filetolink} {output.r1}"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+else:
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+rule create_annotation_table:
+    input:  dir  = ctsource,
+    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
+    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
+            bins = BINS
+    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+rule run_DTU:
+    input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
+    output: session = expand(rules.themall.input.session, combo=combo, scombo=scombo),
+            res = rules.themall.input.res
+    log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: 1  # Due to BPPARAM errors, else int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins   = str.join(os.sep,[BINS, DTUBIN]),
+            compare = comparison,
+            pcombo = scombo if scombo != '' else 'none',
+            outdir = 'DTU/'+combo,
+            ref = os.path.abspath(ANNOTATION),
+            dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
+            # pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+            # lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
+    shell: "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
+# rule filter_significant:
+#     input:  res = rules.run_DTU.output.res
+#     output: sig   = rules.themall.input.sig,
+#             sig_d = rules.themall.input.sig_d,
+#             sig_u = rules.themall.input.sig_u
+#     log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
+#     conda:  "<REPO>/envs/"+DTUENV+".yaml"
+#     threads: 1
+#     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+#             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
+#     shell: "set +o pipefail; for i in {input};do fn=\"${{i##*/}}\"; if [[ -s \"$i\" ]]; then zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane ' next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/SigUP_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn; else touch DTU/{combo}/Sig_$fn DTU/{combo}/SigUP_$fn DTU/{combo}/SigDOWN_$fn; fi; done 2> {log}"
+rule create_summary_snippet:
+    input:  rules.run_DTU.output.res,
+            rules.themall.input.session
+            # rules.filter_significant.output.sig,
+            # rules.filter_significant.output.sig_d,
+            # rules.filter_significant.output.sig_u,
+    output: rules.themall.input.Rmd
+    log:    expand("LOGS/DTU/{combo}create_summary_snippet.log", combo=combo)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins = BINS,
+            abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
+    shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
new file mode 100644
index 00000000..86f58007
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/DRIMSEQ.R",
+  "DTUENV": "drimseq_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
new file mode 100644
index 00000000..c13e2857
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -0,0 +1,511 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-star/drimseq_DTU'
+
+scombo = 'fastqc-trimgalore-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    scombo = scombo,
+    read = "R1|R2",
+    type = "sorted|sorted_unique" if not rundedup else "sorted|sorted_unique|sorted_dedup|sorted_unique_dedup"
+
+logid = 'drimseq_DTU.smk '
+DTUBIN, DTUENV = env_bin_from_config(config,'DTU')
+log.debug(logid+"DTUENV: "+str(DTUENV))
+COUNTBIN, COUNTENV = ['salmon','salmon']#env_bin_from_config(SAMPLES, config,'COUNTING') ##PINNING subreads package to version 1.6.4 due to changes in 2.0.1 gene_id length cutoff that interfers
+comparison = comparable_as_string(config,'DTU')
+compstr = [i.split(":")[0] for i in comparison.split(",")]
+usededup = config.get('RUNDEDUP', False)
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = DTUENV
+unik = get_dict_hash(keydict)
+rule themall:
+    input:  session = expand("DTU/{combo}/DTU_DRIMSEQ_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
+            res_t   = expand("DTU/{combo}/Tables/DTU_DRIMSEQ_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_g   = expand("DTU/{combo}/Tables/DTU_DRIMSEQ_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_p   = expand("DTU/{combo}/Tables/DTU_DRIMSEQ_{scombo}_{comparison}_table_proportions.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_gwp = expand("DTU/{combo}/Tables/DTU_DRIMSEQ_{scombo}_{comparison}_table_genewise-precision.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            fig_F   = expand("DTU/{combo}/Figures/DTU_DRIMSEQ_{scombo}_{comparison}_figure_FeatPerGene.png", combo=combo, comparison=compstr, scombo=scombo),
+            fig_P   = expand("DTU/{combo}/Figures/DTU_DRIMSEQ_{scombo}_{comparison}_figure_Precision.png", combo=combo, comparison=compstr, scombo=scombo),
+            fig_PV  = expand("DTU/{combo}/Figures/DTU_DRIMSEQ_{scombo}_{comparison}_figure_PValues.png", combo=combo, comparison=compstr, scombo=scombo),
+            fig_files = expand("DTU/{combo}/Figures/DTU_DRIMSEQ_{scombo}_{comparison}_list_sig{feature}Figures.tsv", combo=combo, comparison=compstr, scombo=scombo, feature=["Gene","Transcript"]),
+            sig_t    = expand("DTU/{combo}/Tables/Sig_DTU_DRIMSEQ_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dt   = expand("DTU/{combo}/Tables/SigDOWN_DTU_DRIMSEQ_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ut   = expand("DTU/{combo}/Tables/SigUP_DTU_DRIMSEQ_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_g    = expand("DTU/{combo}/Tables/Sig_DTU_DRIMSEQ_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dg   = expand("DTU/{combo}/Tables/SigDOWN_DTU_DRIMSEQ_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ug   = expand("DTU/{combo}/Tables/SigUP_DTU_DRIMSEQ_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+rule salmon_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+if paired == 'paired':
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
+                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
+        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
+else:
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
+        shell:  "ln -s {params.filetolink} {output.r1}"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+else:
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+rule create_annotation_table:
+    input:  dir  = ctsource,
+    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
+    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
+            bins = BINS
+    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+rule run_DTU:
+    input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
+    output: session = rules.themall.input.session,
+            res_t   = rules.themall.input.res_t,
+            res_g   = rules.themall.input.res_g,
+            res_p   = rules.themall.input.res_p,
+            res_gwp = rules.themall.input.res_gwp,
+            fig_F   = rules.themall.input.fig_F,
+            fig_P   = rules.themall.input.fig_P,
+            fig_PV  = rules.themall.input.fig_PV,
+            fig_files = rules.themall.input.fig_files
+    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins   = str.join(os.sep,[BINS, DTUBIN]),
+            compare = comparison,
+            pcombo = scombo if scombo != '' else 'none',
+            outdir = 'DTU/'+combo,
+            ref = os.path.abspath(ANNOTATION),
+            dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
+    shell: "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
+rule filter_significant_drimseq:
+    input:  res_g = rules.themall.input.res_g,
+            res_t = rules.themall.input.res_t
+    output: sig_g   = rules.themall.input.sig_g,
+            sig_dg  = rules.themall.input.sig_dg,
+            sig_ug  = rules.themall.input.sig_ug,
+            sig_t   = rules.themall.input.sig_t,
+            sig_dt  = rules.themall.input.sig_dt,
+            sig_ut  = rules.themall.input.sig_ut
+    log:    "LOGS/DTU/filter_drimseqDTU.log"
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: 1
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+rule create_summary_snippet:
+    input:  rules.run_DTU.output.res_t,
+            rules.run_DTU.output.res_g,
+            rules.run_DTU.output.res_p,
+            rules.run_DTU.output.fig_F,
+            rules.run_DTU.output.fig_P,
+            rules.run_DTU.output.fig_PV,
+            rules.run_DTU.output.fig_files,
+            rules.themall.input.sig_g,
+            rules.themall.input.sig_dg,
+            rules.themall.input.sig_ug,
+            rules.themall.input.sig_t,
+            rules.themall.input.sig_dt,
+            rules.themall.input.sig_ut,
+            rules.themall.input.session
+    output: rules.themall.input.Rmd
+    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins = BINS,
+            abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
+    shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
new file mode 100644
index 00000000..db11a2f9
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
@@ -0,0 +1,77 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DTU": {
+    "COMPARABLE": {
+      "T1-VS-T2": [
+        [
+          "T1"
+        ],
+        [
+          "T2"
+        ]
+      ]
+    },
+    "CUTOFFS": {
+      "lfc": "1.5",
+      "pvalue": "0.05"
+    },
+    "Test": {
+      "dexseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "drimseq": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      },
+      "spit": {
+        "OPTIONS": {
+          "DTU": "",
+          "INDEX": "-d GENOMES/transcripts.fa.gz",
+          "QUANT": "--seqBias --gcBias"
+        }
+      }
+    }
+  },
+  "DTUBIN": "Analysis/DTU/SPIT.py",
+  "DTUENV": "spit_DTU",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
new file mode 100644
index 00000000..f2ae1387
--- /dev/null
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -0,0 +1,503 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-star/spit_DTU'
+
+scombo = 'fastqc-trimgalore-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    scombo = scombo,
+    read = "R1|R2",
+    type = "sorted|sorted_unique" if not rundedup else "sorted|sorted_unique|sorted_dedup|sorted_unique_dedup"
+
+logid = 'spit_DTU.smk '
+DTUBIN, DTUENV = env_bin_from_config(config,'DTU')
+log.debug(logid+"DTUENV: "+str(DTUENV))
+COUNTBIN, COUNTENV = ['salmon','salmon']#env_bin_from_config(SAMPLES, config,'COUNTING') ##PINNING subreads package to version 1.6.4 due to changes in 2.0.1 gene_id length cutoff that interfers
+comparison = comparable_as_string(config,'DTU')
+compstr = [i.split(":")[0] for i in comparison.split(",")]
+usededup = config.get('RUNDEDUP', False)
+TERMINUSENV = 'terminus'
+termpara = tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('TERMINUS', None)
+runterminus = termpara is not None
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = DTUENV
+unik = get_dict_hash(keydict)
+rule themall:
+    input:  session = expand("DTU/{combo}/DTU_SPIT_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
+            res_t   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_g   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            res_i   = expand("DTU/{combo}/Tables/DTU_SPIT_{scombo}_{comparison}_table_ifs.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            fig_PV  = expand("DTU/{combo}/Figures/DTU_SPIT_{scombo}_{comparison}_figure_PValues.png", combo=combo, comparison=compstr, scombo=scombo),
+            fig_W   = expand("DTU/{combo}/Figures/DTU_SPIT_{scombo}_{comparison}_figure_Wasserstein.png", combo=combo, comparison=compstr, scombo=scombo),
+            sig_t    = expand("DTU/{combo}/Tables/Sig_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dt   = expand("DTU/{combo}/Tables/SigDOWN_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ut   = expand("DTU/{combo}/Tables/SigUP_DTU_SPIT_{scombo}_{comparison}_table_transcripts.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_g    = expand("DTU/{combo}/Tables/Sig_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_dg   = expand("DTU/{combo}/Tables/SigDOWN_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            sig_ug   = expand("DTU/{combo}/Tables/SigUP_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
+            Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+rule salmon_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+if paired == 'paired':
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
+                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
+        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
+else:
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
+        shell:  "ln -s {params.filetolink} {output.r1}"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+else:
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+rule create_annotation_table:
+    input:  dir  = ctsource,
+    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
+    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    conda:  "<REPO>/envs/"+COUNTENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
+            bins = BINS
+    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+rule run_DTU:
+    input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
+    output: session = rules.themall.input.session,
+            res_t   = rules.themall.input.res_t,
+            res_g   = rules.themall.input.res_g,
+            res_i   = rules.themall.input.res_i,
+            fig_PV  = rules.themall.input.fig_PV,
+            fig_W   = rules.themall.input.fig_W
+    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins   = str.join(os.sep,[BINS, DTUBIN]),
+            compare = comparison,
+            pcombo = scombo if scombo != '' else 'none',
+            outdir = 'DTU/'+combo,
+            ref = os.path.abspath(ANNOTATION),
+            dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
+    shell: "python3 {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
+rule filter_significant_spit:
+    input:  res_g = rules.themall.input.res_g,
+            res_t = rules.themall.input.res_t
+    output: sig_g   = rules.themall.input.sig_g,
+            sig_dg  = rules.themall.input.sig_dg,
+            sig_ug  = rules.themall.input.sig_ug,
+            sig_t   = rules.themall.input.sig_t,
+            sig_dt  = rules.themall.input.sig_dt,
+            sig_ut  = rules.themall.input.sig_ut
+    log:    "LOGS/DTU/filter_spitDTU.log"
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: 1
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+rule create_summary_snippet:
+    input:  rules.run_DTU.output.res_t,
+            rules.run_DTU.output.res_g,
+            rules.run_DTU.output.res_i,
+            rules.run_DTU.output.fig_PV,
+            rules.run_DTU.output.fig_W,
+            rules.themall.input.sig_g,
+            rules.themall.input.sig_dg,
+            rules.themall.input.sig_ug,
+            rules.themall.input.sig_t,
+            rules.themall.input.sig_dt,
+            rules.themall.input.sig_ut,
+            rules.themall.input.session
+    output: rules.themall.input.Rmd
+    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    conda:  "<REPO>/envs/"+DTUENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
+    params: bins = BINS,
+            abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
+    shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subconfig.json
new file mode 100644
index 00000000..49c01b6e
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": ""
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
new file mode 100644
index 00000000..f74d4542
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -0,0 +1,554 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"        
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in=$r1 out=$o &> $r 
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+MAPPARAMS = get_always('bwa_params_MAP') ?: ''
+IDXBIN = MAPBIN.split('_')[0]
+MAPBIN = MAPBIN.replace('_', ' ')
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process bwa_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "bwa.idx")                          "$MAPIDX"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
+        else                                                "$MAPUIDX"
+    }
+    input:
+    path genome
+    output:
+    path "bwa.idx", emit: idx
+    path "bwa_*", emit: bwidx
+    script:
+    gen =  genome.getName()
+    """
+    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    """
+}
+process bwa_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*.sam.gz", emit: maps
+    path "*fastq.gz", includeInputs:false, emit: unmapped
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf1 = fn+"_R1_unmapped.fastq.gz"
+        uf2 = fn+"_R2_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        """
+    }else{
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf = fn+"_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        """
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        bwa_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        bwa_idx(genomefile)
+        bwa_mapping(bwa_idx.out.bwidx.combine(collection))
+    }
+    emit:
+    mapped  = bwa_mapping.out.maps
+    logs = bwa_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subconfig.json
new file mode 100644
index 00000000..8311d49f
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
new file mode 100644
index 00000000..6f38d6fa
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -0,0 +1,584 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"        
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in=$r1 out=$o &> $r 
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('star_params_INDEX') ?: ''
+MAPPARAMS = get_always('star_params_MAP') ?: ''
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process star_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
+        else                                             "$MAPUIDX"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "$MAPUIDXNAME", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    """
+}
+process star_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (PAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (STRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (STRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        star_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        annofile = Channel.fromPath(MAPANNO)
+        star_idx(genomefile, annofile)
+        star_mapping(star_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = star_mapping.out.maps
+    logs = star_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subconfig.json
new file mode 100644
index 00000000..7b107b69
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": ""
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
new file mode 100644
index 00000000..b4b87dfe
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -0,0 +1,554 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o -p $p $r1 $r2 &> $r
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o $reads &> $r
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+MAPPARAMS = get_always('bwa_params_MAP') ?: ''
+IDXBIN = MAPBIN.split('_')[0]
+MAPBIN = MAPBIN.replace('_', ' ')
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process bwa_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "bwa.idx")                          "$MAPIDX"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
+        else                                                "$MAPUIDX"
+    }
+    input:
+    path genome
+    output:
+    path "bwa.idx", emit: idx
+    path "bwa_*", emit: bwidx
+    script:
+    gen =  genome.getName()
+    """
+    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    """
+}
+process bwa_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*.sam.gz", emit: maps
+    path "*fastq.gz", includeInputs:false, emit: unmapped
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf1 = fn+"_R1_unmapped.fastq.gz"
+        uf2 = fn+"_R2_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        """
+    }else{
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf = fn+"_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        """
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        bwa_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        bwa_idx(genomefile)
+        bwa_mapping(bwa_idx.out.bwidx.combine(collection))
+    }
+    emit:
+    mapped  = bwa_mapping.out.maps
+    logs = bwa_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subconfig.json
new file mode 100644
index 00000000..5aac3911
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
new file mode 100644
index 00000000..5f91ce8f
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -0,0 +1,584 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o -p $p $r1 $r2 &> $r
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o $reads &> $r
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('star_params_INDEX') ?: ''
+MAPPARAMS = get_always('star_params_MAP') ?: ''
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process star_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
+        else                                             "$MAPUIDX"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "$MAPUIDXNAME", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    """
+}
+process star_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (PAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (STRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (STRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        star_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        annofile = Channel.fromPath(MAPANNO)
+        star_idx(genomefile, annofile)
+        star_mapping(star_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = star_mapping.out.maps
+    logs = star_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subconfig.json
new file mode 100644
index 00000000..be57a0c5
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": ""
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
new file mode 100644
index 00000000..8188d76a
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -0,0 +1,549 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        """
+        $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+    else{
+        """
+        $TRIMBIN --cores ${task.cpus} --gzip $TRIMPARAMS $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+MAPPARAMS = get_always('bwa_params_MAP') ?: ''
+IDXBIN = MAPBIN.split('_')[0]
+MAPBIN = MAPBIN.replace('_', ' ')
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process bwa_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename == "bwa.idx")                          "$MAPIDX"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
+        else                                                "$MAPUIDX"
+    }
+    input:
+    path genome
+    output:
+    path "bwa.idx", emit: idx
+    path "bwa_*", emit: bwidx
+    script:
+    gen =  genome.getName()
+    """
+    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    """
+}
+process bwa_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+        saveAs: {filename ->
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*.sam.gz", emit: maps
+    path "*fastq.gz", includeInputs:false, emit: unmapped
+    path "*.log", emit: logs
+    script:
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf1 = fn+"_R1_unmapped.fastq.gz"
+        uf2 = fn+"_R2_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        """
+    }else{
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")
+        pf = fn+"_mapped.sam.gz"
+        uf = fn+"_unmapped.fastq.gz"
+        lf = "bwa_"+fn+".log"
+        """
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        """
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    collection.filter(~/.fastq.gz/)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        bwa_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        bwa_idx(genomefile)
+        bwa_mapping(bwa_idx.out.bwidx.combine(collection))
+    }
+    emit:
+    mapped  = bwa_mapping.out.maps
+    logs = bwa_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subconfig.json
new file mode 100644
index 00000000..3aa873e6
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
new file mode 100644
index 00000000..4cfad930
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -0,0 +1,579 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    if (!params.containsKey(parameter)){
+        params.put(parameter, null)
+    }
+    return params[parameter]
+}
+REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+BINS = get_always('BINS')
+THREADS = get_always('MAXTHREAD')
+PAIRED = get_always('PAIRED') ?: null
+RUNDEDUP = get_always('RUNDEDUP') ?: null
+PREDEDUP = get_always('PREDEDUP') ?: null
+STRANDED = get_always('STRANDED') ?: null
+IP = get_always('IP') ?: null
+CONDITION = get_always('CONDITION') ?: null
+COMBO = get_always('COMBO') ?: ''
+SCOMBO = get_always('SCOMBO') ?: ''
+SAMPLES = get_always('SAMPLES').split(',') ?: null
+LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+SETS = get_always('SETS') ?: null
+dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+if (PAIRED == 'paired' || PAIRED == 'singlecell'){
+    RSAMPLES = SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    RSAMPLES=SAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+samples_ch = Channel.fromPath(RSAMPLES)
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_QC') ?: ''
+process qc_raw{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch)
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+TRIMENV=get_always('TRIMMINGENV')
+TRIMBIN=get_always('TRIMMINGBIN')
+TRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
+process trim{
+    conda "<REPO>/envs/$TRIMENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (PAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        """
+        $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+    else{
+        """
+        $TRIMBIN --cores ${task.cpus} --gzip $TRIMPARAMS $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( PREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+DEDUPENV=get_always('DEDUPENV')
+DEDUPBIN=get_always('DEDUPBIN')
+DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+process dedup_bam{
+    conda "<REPO>/envs/$DEDUPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+IDXPARAMS = get_always('star_params_INDEX') ?: ''
+MAPPARAMS = get_always('star_params_MAP') ?: ''
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process star_idx{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
+        else                                             "$MAPUIDX"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "$MAPUIDXNAME", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    """
+}
+process star_mapping{
+    conda "<REPO>/envs/$MAPENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (PAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (STRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (STRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(MAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        star_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        annofile = Channel.fromPath(MAPANNO)
+        star_idx(genomefile, annofile)
+        star_mapping(star_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = star_mapping.out.maps
+    logs = star_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (COMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus THREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+process mqc{
+    conda "<REPO>/envs/$QCENV"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy)
+    TRIMMING(dummy)
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/_filelist.txt b/tests/golden/config_Test/nf/_filelist.txt
new file mode 100644
index 00000000..ec57aa75
--- /dev/null
+++ b/tests/golden/config_Test/nf/_filelist.txt
@@ -0,0 +1,12 @@
+Test_fastqc-bbduk-picard-bwa_subconfig.json
+Test_fastqc-bbduk-picard-bwa_subflow.nf
+Test_fastqc-bbduk-picard-star_subconfig.json
+Test_fastqc-bbduk-picard-star_subflow.nf
+Test_fastqc-cutadapt-picard-bwa_subconfig.json
+Test_fastqc-cutadapt-picard-bwa_subflow.nf
+Test_fastqc-cutadapt-picard-star_subconfig.json
+Test_fastqc-cutadapt-picard-star_subflow.nf
+Test_fastqc-trimgalore-picard-bwa_subconfig.json
+Test_fastqc-trimgalore-picard-bwa_subflow.nf
+Test_fastqc-trimgalore-picard-star_subconfig.json
+Test_fastqc-trimgalore-picard-star_subflow.nf
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subconfig.json
new file mode 100644
index 00000000..299a9cf6
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "bwa": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": ""
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "bbduk": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
new file mode 100644
index 00000000..dfa62d8d
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -0,0 +1,839 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-bbduk-picard-bwa'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} t={threads} in1={input.r1} in2={input.r2} out1={output.o1} out2={output.o2} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1,
+                o2 = rules.bbduk_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
+                trim = TRIMBIN,
+        shell:  "{params.trim} t={threads} in={input.r1} out={output.o1} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  ref = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: 1
+    params: indexer = MAPPERBIN.split(' ')[0],
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            linkidx = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.uidx[0]).split(os.sep)[:-1]))) if PREFIX != '' else str(os.path.abspath(str(output.uidx[0]))),
+            tolink = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.idx).split(os.sep)[:-1])))
+    shell:  "if [[ -f \"{output.uidx}\\/*\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\" ; else {params.indexer} index -p {output.uidx} {params.ipara} {input.ref} 2> {log} && ln -fs {params.linkidx} {output.idx} && touch {output.uidx};fi"
+bwaalg = MAPPERBIN.split(' ')[1]
+if bwaalg == 'mem':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    index = rules.generate_index.output.uidx,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.index} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to continue the workflow
+    if paired == 'paired': # handled like sampe
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+#                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+#                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} > {output.sai1} 2>> {log} && {params.mapp} {params.mpara} -t {threads} {input.ref} {input.r2} > {output.sai2} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+    else: #handled like samse
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log} | tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+elif bwaalg == 'samse':
+    rule mapping:
+        input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'sampe':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+elif bwaalg == 'bwasw':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subconfig.json
new file mode 100644
index 00000000..c09d4b6a
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "star": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "bbduk": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
new file mode 100644
index 00000000..99981727
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -0,0 +1,754 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-bbduk-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} t={threads} in1={input.r1} in2={input.r2} out1={output.o1} out2={output.o2} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1,
+                o2 = rules.bbduk_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
+                trim = TRIMBIN,
+        shell:  "{params.trim} t={threads} in={input.r1} out={output.o1} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/STAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subconfig.json
new file mode 100644
index 00000000..f7b2c00a
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "bwa": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": ""
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "cutadapt": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
new file mode 100644
index 00000000..e93ded03
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -0,0 +1,839 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-cutadapt-picard-bwa'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} -p {output.o2} {input.r1} {input.r2} &> {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1,
+                o2 = rules.cutadapt_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN,
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} {input.r1} > {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  ref = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: 1
+    params: indexer = MAPPERBIN.split(' ')[0],
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            linkidx = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.uidx[0]).split(os.sep)[:-1]))) if PREFIX != '' else str(os.path.abspath(str(output.uidx[0]))),
+            tolink = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.idx).split(os.sep)[:-1])))
+    shell:  "if [[ -f \"{output.uidx}\\/*\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\" ; else {params.indexer} index -p {output.uidx} {params.ipara} {input.ref} 2> {log} && ln -fs {params.linkidx} {output.idx} && touch {output.uidx};fi"
+bwaalg = MAPPERBIN.split(' ')[1]
+if bwaalg == 'mem':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    index = rules.generate_index.output.uidx,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.index} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to continue the workflow
+    if paired == 'paired': # handled like sampe
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+#                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+#                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} > {output.sai1} 2>> {log} && {params.mapp} {params.mpara} -t {threads} {input.ref} {input.r2} > {output.sai2} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+    else: #handled like samse
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log} | tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+elif bwaalg == 'samse':
+    rule mapping:
+        input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'sampe':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+elif bwaalg == 'bwasw':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subconfig.json
new file mode 100644
index 00000000..30fe9028
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "star": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "cutadapt": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
new file mode 100644
index 00000000..d8015aa1
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -0,0 +1,754 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-cutadapt-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} -p {output.o2} {input.r1} {input.r2} &> {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1,
+                o2 = rules.cutadapt_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN,
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} {input.r1} > {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/STAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subconfig.json
new file mode 100644
index 00000000..f7e7cab3
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "bwa": "bwa mem"
+    },
+    "Test": {
+      "bwa": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": ""
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "bwa mem",
+  "MAPPINGENV": "bwa",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "trimgalore": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
new file mode 100644
index 00000000..c80ab9ea
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -0,0 +1,846 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-bwa'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+#outdir = 'TRIMMED_FASTQ'
+#wildcard_constraints:
+#    file = '|'.join(list(samplecond(SAMPLES, config))),
+#    read = "R1|R2"
+#    outdir = outdir
+#rule trimthemall:
+#    input: expand("{outdir}{file}_{read}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config), read=["R1","R2"]) if paired == \'paired\' else expand("{outdir}{file}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config))
+if paired == 'paired':
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:   "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --paired --gzip {params.tpara} -o {params.odir} {input.r1} {input.r2} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1,
+                o2 = rules.trimgalore_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --gzip {params.tpara} -o {params.odir} {input.r1} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  ref = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: 1
+    params: indexer = MAPPERBIN.split(' ')[0],
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
+            linkidx = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.uidx[0]).split(os.sep)[:-1]))) if PREFIX != '' else str(os.path.abspath(str(output.uidx[0]))),
+            tolink = lambda wildcards, output: str(os.path.abspath(str.join(os.sep, str(output.idx).split(os.sep)[:-1])))
+    shell:  "if [[ -f \"{output.uidx}\\/*\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\" ; else {params.indexer} index -p {output.uidx} {params.ipara} {input.ref} 2> {log} && ln -fs {params.linkidx} {output.idx} && touch {output.uidx};fi"
+bwaalg = MAPPERBIN.split(' ')[1]
+if bwaalg == 'mem':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    index = rules.generate_index.output.uidx,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.index} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+                    #idx = lambda wildcards, input: str.join(os.sep,[str(input.index), PREFIX]) if PREFIX != '' else input.index
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to continue the workflow
+    if paired == 'paired': # handled like sampe
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+#                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+#                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} > {output.sai1} 2>> {log} && {params.mapp} {params.mpara} -t {threads} {input.ref} {input.r2} > {output.sai2} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+    else: #handled like samse
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                    mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN,
+                    mapp1 = MAPPERBIN.split(' ')[0]
+            shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log} | tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+### FOR LATER IF WE EVER NEED aln MODE
+#        rule mapping:
+#            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+#                    #index = lambda wildcards: expand(rules.generate_index.output.idx, ref=REFERENCE, dir=source_from_sample(wildcards.file, config), gen=genome(wildcards.file, config), name=namefromfile(wildcards.file, config), mape=MAPPERENV, extension=check_tool_params(wildcards.file, None, config, 'MAPPING', 2)),
+#                    ref = lambda wildcards: expand(rules.generate_index.input.fa, ref=REFERENCE, dir = source_from_sample(wildcards.file, config), gen =genome(wildcards.file, config), name=namefromfile(wildcards.file, config))
+#            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+#                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
+#                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+#            threads: MAXTHREAD
+#            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
+#                    mapp=MAPPERBIN
+#            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} 2>> {log} && touch {output.unmapped} && touch {output.mapped}"
+elif bwaalg == 'samse':
+    rule mapping:
+        input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+elif bwaalg == 'sampe':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                ref = REFERENCE
+        output: sai1 = report("MAPPED/{combo}/{file}_mapped.R1.sai", category="MAPPING"),
+                sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
+                mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                mapp1 = MAPPERBIN.split(' ')[0]
+        shell:  "{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+elif bwaalg == 'bwasw':
+    if paired == 'paired':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell: "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+    else:
+        rule mapping:
+            input:  query = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    mapp = MAPPERBIN
+            shell:  "{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subconfig.json
new file mode 100644
index 00000000..1584f1af
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "star": "STAR"
+    },
+    "Test": {
+      "star": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "STAR",
+  "MAPPINGENV": "star",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "trimgalore": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
new file mode 100644
index 00000000..71c0b7f1
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -0,0 +1,761 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+#outdir = 'TRIMMED_FASTQ'
+#wildcard_constraints:
+#    file = '|'.join(list(samplecond(SAMPLES, config))),
+#    read = "R1|R2"
+#    outdir = outdir
+#rule trimthemall:
+#    input: expand("{outdir}{file}_{read}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config), read=["R1","R2"]) if paired == \'paired\' else expand("{outdir}{file}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config))
+if paired == 'paired':
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:   "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --paired --gzip {params.tpara} -o {params.odir} {input.r1} {input.r2} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1,
+                o2 = rules.trimgalore_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --gzip {params.tpara} -o {params.odir} {input.r1} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/STAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/STAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/golden/config_Test/smk/_filelist.txt b/tests/golden/config_Test/smk/_filelist.txt
new file mode 100644
index 00000000..2b49db00
--- /dev/null
+++ b/tests/golden/config_Test/smk/_filelist.txt
@@ -0,0 +1,12 @@
+Test_fastqc-bbduk-picard-bwa_subconfig.json
+Test_fastqc-bbduk-picard-bwa_subsnake.smk
+Test_fastqc-bbduk-picard-star_subconfig.json
+Test_fastqc-bbduk-picard-star_subsnake.smk
+Test_fastqc-cutadapt-picard-bwa_subconfig.json
+Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+Test_fastqc-cutadapt-picard-star_subconfig.json
+Test_fastqc-cutadapt-picard-star_subsnake.smk
+Test_fastqc-trimgalore-picard-bwa_subconfig.json
+Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+Test_fastqc-trimgalore-picard-star_subconfig.json
+Test_fastqc-trimgalore-picard-star_subsnake.smk
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index 0706af65..d2b6dcf4 100755
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -2,6 +2,7 @@
 import io
 import os
 import shutil
+import tempfile
 import unittest
 from contextlib import redirect_stdout
 
@@ -11,6 +12,7 @@
     NestedDefaultDict,
     add_to_innermost_key_by_list,
     check_ref,
+    cluster2trna,
     comment_remover,
     convertcol,
     depth,
@@ -42,6 +44,7 @@
     rmempty,
     sub_dict,
     subset_dict,
+    toarray,
     value_extract,
     yield_from_dict,
 )
@@ -177,9 +180,16 @@ def test_gethighest_dict(self):
         self.assertEqual(gethighest_dict(a, n), {"a": 5, "e": 4, "c": 3})
 
     def test_toarray(self):
-        # Assuming toarray function converts a file to np.array
-        # This test might need to create a temporary file to fully test toarray functionality
-        pass
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".tsv", delete=False) as fh:
+            fh.write("a\t1.5\nb\t2.5\nc\tnan\n")
+            path = fh.name
+        try:
+            arr = toarray(path, 1)
+            self.assertEqual(arr[0], 1.5)
+            self.assertEqual(arr[1], 2.5)
+            self.assertTrue(np.isnan(arr[2]))
+        finally:
+            os.remove(path)
 
     def test_convertcol(self):
         self.assertEqual(convertcol("1.23"), 1.23)
@@ -215,9 +225,24 @@ def test_idfromfa(self):
         self.assertEqual(idfromfa(id), ["cluster1", "chr19", "+"])
 
     def test_cluster2trna(self):
-        # Assuming cluster2trna function converts cluster to tRNA
-        # This test might need to create a temporary file to fully test cluster2trna functionality
-        pass
+        fasta = (
+            ">cluster1:chr19.tRNA5-LysCTT(+)\nACGT\n"
+            ">cluster1:chr19.tRNA6-LysCTT(+)\nTGCA\n"
+            ">cluster2:chr1.tRNA25-ArgTCT(-)\nGGGG\n"
+        )
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".fa", delete=False) as fh:
+            fh.write(fasta)
+            path = fh.name
+        try:
+            result = cluster2trna(path)
+            self.assertEqual(
+                result["cluster"]["CLUSTER1"], ["TRNA5-LYSCTT", "TRNA6-LYSCTT"]
+            )
+            self.assertEqual(result["cluster"]["CLUSTER2"], ["TRNA25-ARGTCT"])
+            self.assertEqual(result["tRNA"]["CHR19"]["+"], ["TRNA5-LYSCTT", "TRNA6-LYSCTT"])
+            self.assertEqual(result["tRNA"]["CHR1"]["-"], ["TRNA25-ARGTCT"])
+        finally:
+            os.remove(path)
 
     def test_check_ref(self):
         reference = "test_ref"
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
new file mode 100644
index 00000000..45f1e1b0
--- /dev/null
+++ b/tests/test_Workflows.py
@@ -0,0 +1,357 @@
+import glob
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("snakemake")
+
+from snakemake.common.configfile import load_configfile  # noqa: E402
+
+import MONSDA.Params as mp  # noqa: E402
+import MONSDA.Workflows as mw  # noqa: E402
+
+REPO = Path(__file__).resolve().parents[1]
+DATA = REPO / "tests" / "data"
+GOLDEN = REPO / "tests" / "golden"
+
+UPDATE = bool(os.environ.get("UPDATE_GOLDEN"))
+
+
+@pytest.fixture(autouse=True)
+def _repo_template_paths():
+    """Point the generators at the in-repo workflow/env templates.
+
+    In a dev checkout MONSDA is not pip-installed, so the module-level
+    ``workflowpath``/``envpath`` (which assume a site-packages layout) do not
+    resolve. Redirect them to the repository copies for the duration of a test.
+    """
+    old_wf, old_env = mw.workflowpath, mw.envpath
+    mw.workflowpath = str(REPO / "workflows")
+    mw.envpath = str(REPO / "envs") + os.sep
+    yield
+    mw.workflowpath, mw.envpath = old_wf, old_env
+
+
+def _load(name):
+    return load_configfile(str(DATA / name))
+
+
+def _normalize(text, workdir):
+    return text.replace(str(workdir), "<WORKDIR>").replace(str(REPO), "<REPO>")
+
+
+def _check_golden(relpath, content):
+    path = GOLDEN / relpath
+    if UPDATE:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        return
+    assert path.exists(), (
+        f"missing golden snapshot {relpath!s}; regenerate with UPDATE_GOLDEN=1"
+    )
+    assert content == path.read_text(), (
+        f"generator output drifted from golden snapshot {relpath!s}; "
+        f"review the diff and, if intended, regenerate with UPDATE_GOLDEN=1"
+    )
+
+
+@pytest.fixture
+def workdir(tmp_path):
+    """A temp working directory exposing tests/data inputs via symlinks."""
+    for item in os.listdir(DATA):
+        os.symlink(DATA / item, tmp_path / item)
+    old = os.getcwd()
+    os.chdir(tmp_path)
+    try:
+        yield tmp_path
+    finally:
+        os.chdir(old)
+
+
+# --------------------------------------------------------------------------- #
+# Unit tests: pure helpers
+# --------------------------------------------------------------------------- #
+
+
+class TestCreateSubworkflow:
+    def test_returns_tool_and_config(self):
+        cfg = _load("config_fgumi_test.json")
+        conditions = mp.get_conditions(cfg)
+        toollist, configs = mw.create_subworkflow(cfg, "DEDUP", conditions)
+        assert toollist == [["fgumi", "fgumi"]]
+        assert len(configs) == 1
+        assert configs[0]["RUNDEDUP"] == "enabled"
+        assert "fgumi" in configs[0]["DEDUP"]["Test"]["umi"]
+
+    def test_tools_key_without_env_bin(self):
+        cfg = _load("config_Test.json")
+        conditions = mp.get_conditions(cfg)
+        toollist, configs = mw.create_subworkflow(cfg, "MAPPING", conditions)
+        tools = sorted(t[0] for t in toollist)
+        assert tools
+        assert all(len(pair) == 2 for pair in toollist)
+
+    def test_missing_env_bin_logs_error(self, caplog):
+        cfg = {
+            "MAXTHREADS": "1",
+            "WORKFLOWS": "MAPPING",
+            "SETTINGS": {"Test": {"umi": {"SAMPLES": ["S1"]}}},
+            "MAPPING": {"Test": {"umi": {}}},
+        }
+        with caplog.at_level("ERROR"):
+            toollist, _ = mw.create_subworkflow(cfg, "MAPPING", [("Test", "umi")])
+        assert toollist == []
+        assert any(
+            "No tool environment found for MAPPING" in r.message
+            for r in caplog.records
+        )
+        assert any(
+            "No tool binary found for MAPPING" in r.message for r in caplog.records
+        )
+
+
+class TestGetCombo:
+    def test_single_tool(self):
+        cfg = _load("config_fgumi_test.json")
+        conditions = mp.get_conditions(cfg)
+        combos = mw.get_combo(["DEDUP"], cfg, conditions)
+        materialized = {c: [list(x) for x in combos[c]] for c in combos}
+        assert materialized == {("Test", "umi"): [[{"DEDUP": "fgumi"}]]}
+
+    def test_none_when_no_workflows(self):
+        cfg = _load("config_fgumi_test.json")
+        conditions = mp.get_conditions(cfg)
+        assert mw.get_combo(None, cfg, conditions) is None
+        assert mw.get_combo([], cfg, conditions) is None
+
+    def test_multi_tool_product(self):
+        cfg = _load("config_Test.json")
+        conditions = mp.get_conditions(cfg)
+        combos = mw.get_combo(["MAPPING"], cfg, conditions)
+        counts = {c: len(list(combos[c])) for c in combos}
+        assert all(n >= 1 for n in counts.values())
+
+
+# --------------------------------------------------------------------------- #
+# Golden-file / snapshot tests: file-emitting generators
+# --------------------------------------------------------------------------- #
+
+
+def _generate(engine, workdir):
+    cfg = _load("config_Test.json")
+    conditions = mp.get_conditions(cfg)
+    _pre, sub, _post = mw.get_processes(cfg)
+    samples = mp.get_samples(cfg)
+    combos = mw.get_combo(sub, cfg, conditions)
+    if engine == "smk":
+        subdir = "SubSnakes"
+        mp.create_skeleton(subdir, None)
+        mw.make_sub(sub, cfg, samples, conditions, subdir, "INFO", combinations=combos)
+    else:
+        subdir = "SubFlows"
+        mp.create_skeleton(subdir, None)
+        mw.nf_make_sub(
+            sub, cfg, samples, conditions, subdir, "INFO", combinations=combos
+        )
+    return subdir
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_sub_golden(engine, workdir):
+    subdir = _generate(engine, workdir)
+    produced = sorted(
+        os.path.relpath(p, workdir) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    assert produced, "generator produced no files"
+
+    for rel in produced:
+        raw = Path(workdir / rel).read_text()
+        if rel.endswith(".json"):
+            raw = json.dumps(json.loads(raw), indent=2, sort_keys=True)
+        content = _normalize(raw, workdir)
+        _check_golden(f"config_Test/{engine}/{os.path.basename(rel)}", content)
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_sub_file_set_stable(engine, workdir):
+    subdir = _generate(engine, workdir)
+    names = sorted(
+        os.path.basename(p) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    _check_golden(f"config_Test/{engine}/_filelist.txt", "\n".join(names) + "\n")
+
+
+# --------------------------------------------------------------------------- #
+# Golden-file snapshot for the DTU postprocessing trio (drimseq/dexseq/spit).
+# These share a large amount of scaffolding; the snapshot pins current output
+# so the shared-base extraction can be reviewed as an explicit, minimal diff.
+# --------------------------------------------------------------------------- #
+
+
+def _generate_dtu(engine, workdir):
+    cfg = _load("config_DTU_test.json")
+    conditions = mp.get_conditions(cfg)
+    _pre, sub, _post = mw.get_processes(cfg)
+    combos = mw.get_combo(sub, cfg, conditions)
+    samples = mp.get_samples_postprocess(cfg, "DTU")
+    if engine == "smk":
+        subdir = "SubPostSnakes"
+        mp.create_skeleton(subdir, None)
+        mw.make_post(
+            "DTU", cfg, samples, conditions, subdir, "INFO", combinations=combos
+        )
+    else:
+        subdir = "SubPostFlows"
+        mp.create_skeleton(subdir, None)
+        mw.nf_make_post(
+            "DTU", cfg, samples, conditions, subdir, "INFO", combinations=combos
+        )
+    return subdir
+
+
+def _sort_string_lists(node):
+    """Sort lists whose members are all strings so set-derived orderings
+    (e.g. postprocess SAMPLES) do not make the snapshot flaky."""
+    if isinstance(node, dict):
+        return {k: _sort_string_lists(v) for k, v in node.items()}
+    if isinstance(node, list):
+        items = [_sort_string_lists(v) for v in node]
+        if all(isinstance(v, str) for v in items):
+            return sorted(items)
+        return items
+    return node
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_post_dtu_golden(engine, workdir):
+    subdir = _generate_dtu(engine, workdir)
+    produced = sorted(
+        os.path.relpath(p, workdir) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    assert produced, "generator produced no files"
+
+    for rel in produced:
+        raw = Path(workdir / rel).read_text()
+        if rel.endswith(".json"):
+            data = _sort_string_lists(json.loads(raw))
+            raw = json.dumps(data, indent=2, sort_keys=True)
+        content = _normalize(raw, workdir)
+        _check_golden(f"config_DTU/{engine}/{os.path.basename(rel)}", content)
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_post_dtu_file_set_stable(engine, workdir):
+    subdir = _generate_dtu(engine, workdir)
+    names = sorted(
+        os.path.basename(p) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    _check_golden(f"config_DTU/{engine}/_filelist.txt", "\n".join(names) + "\n")
+
+
+# --------------------------------------------------------------------------- #
+# Cross-engine consistency: the Snakemake and Nextflow generators must expose
+# the same tool matrix, env/bin selection and per-step OPTIONS for one config.
+# The on-disk nesting differs between engines (smk nests OPTIONS under the tool
+# name, nf flattens it), so comparisons are made on the semantic content.
+# --------------------------------------------------------------------------- #
+
+WORKFLOW_KEYS = ("QC", "TRIMMING", "MAPPING", "DEDUP", "COUNTING", "TRACKS")
+
+
+def _combo_name(fname):
+    for suffix in ("_subconfig.json", "_subsnake.smk", "_subflow.nf"):
+        if fname.endswith(suffix):
+            return fname[: -len(suffix)]
+    return fname
+
+
+def _subconfigs_by_combo(subdir):
+    out = {}
+    for path in glob.glob(os.path.join(subdir, "*_subconfig.json")):
+        with open(path) as fh:
+            out[_combo_name(os.path.basename(path))] = json.load(fh)
+    return out
+
+
+def _collect_options(node):
+    """Recursively merge every OPTIONS dict found under a config subtree."""
+    merged = {}
+    if isinstance(node, dict):
+        for key, val in node.items():
+            if key == "OPTIONS" and isinstance(val, dict):
+                merged.update(val)
+            else:
+                merged.update(_collect_options(val))
+    return merged
+
+
+@pytest.fixture
+def both_engines(workdir):
+    smk = _subconfigs_by_combo(_generate("smk", workdir))
+    nf = _subconfigs_by_combo(_generate("nf", workdir))
+    return smk, nf
+
+
+def test_engines_expose_same_combos(both_engines):
+    smk, nf = both_engines
+    assert set(smk) == set(nf)
+    assert smk, "no combos generated"
+
+
+def test_engines_expose_same_env_and_bin(both_engines):
+    smk, nf = both_engines
+    for combo in smk:
+        sc, nc = smk[combo], nf[combo]
+        scalars = {
+            k: v
+            for k, v in sc.items()
+            if k.endswith(("ENV", "BIN")) and isinstance(v, str)
+        }
+        for key, val in scalars.items():
+            assert nc.get(key) == val, (
+                f"{combo}: {key} drift smk={val!r} nf={nc.get(key)!r}"
+            )
+
+
+def test_engines_expose_same_options(both_engines):
+    smk, nf = both_engines
+    for combo in smk:
+        sc, nc = smk[combo], nf[combo]
+        for wf in WORKFLOW_KEYS:
+            if wf not in sc and wf not in nc:
+                continue
+            smk_opts = _collect_options(sc.get(wf, {}))
+            nf_opts = _collect_options(nc.get(wf, {}))
+            assert smk_opts == nf_opts, (
+                f"{combo}/{wf}: OPTIONS drift smk={smk_opts!r} nf={nf_opts!r}"
+            )
+
+
+def test_engines_expose_same_tools(both_engines):
+    smk, nf = both_engines
+    for combo in smk:
+        sc, nc = smk[combo], nf[combo]
+        for wf in WORKFLOW_KEYS:
+            if wf not in sc and wf not in nc:
+                continue
+            assert sc.get(wf, {}).get("TOOLS") == nc.get(wf, {}).get("TOOLS"), (
+                f"{combo}/{wf}: TOOLS drift"
+            )
+
+
+def test_oras_namespace_and_registry_rewrite():
+    line = 'container: "oras://jfallmann/monsda:"+MAPPERENV'
+    try:
+        assert mw._rewrite_oras(line) == (
+            'container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV'
+        )
+        mw.set_oras_namespace("myuser/myrepo")
+        mw.set_oras_registry("ghcr.io")
+        assert mw._rewrite_oras(line) == (
+            'container: "oras://ghcr.io/myuser/myrepo:"+MAPPERENV'
+        )
+    finally:
+        mw.set_oras_namespace(mw.oras_default_namespace)
+        mw.set_oras_registry("docker.io")
diff --git a/workflows/dexseq_DTU.nf b/workflows/dexseq_DTU.nf
index aa36fc82..f4f6d2b0 100644
--- a/workflows/dexseq_DTU.nf
+++ b/workflows/dexseq_DTU.nf
@@ -24,6 +24,8 @@ COUNTENV = 'salmon'
 
 //DTU PROCESSES
 
+include { salmon_quant; create_summary_snippet; terminus_collapse } from "dtu_base.nf"
+
 process salmon_idx{
     conda "$COUNTENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$COUNTENV"
@@ -59,68 +61,6 @@ process salmon_idx{
 
 }
 
-process salmon_quant{
-    conda "$COUNTENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
-    }
-
-    input:
-    path reads
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-
-    idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
-            stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
-            stranded = '-l ISR'
-        }else{
-            stranded = '-l IU'
-        }
-        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
-        r1 = rs[0]
-        r2 = rs[1]
-        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
-            stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
-            stranded = '-l SR'
-        }else{
-            stranded = '-l U'
-        }
-        read = reads[1]
-        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }
-}
-
 process prepare_dtu_annotation{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -185,34 +125,6 @@ process run_dexseq{
     """
 }
 
-process create_summary_snippet{
-    conda "$DTUENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'link',
-    saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
-    }
-
-    input:
-    path de
-
-    output:
-    path "*.Rmd", emit: snps
-    path "log", emit: log
-
-    script:
-    inlist = de.toString()
-    // inlist = de.toList()  // { $workflow.projectDir += "$it.code,"  }
-    """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
-    """
-}
-
 process collect_dexseq{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -229,32 +141,6 @@ process collect_dexseq{
     """
 }
 
-process terminus_collapse{
-    conda "terminus.yaml"
-    container "oras://jfallmann/monsda:terminus"
-    cpus THREADS
-	cache 'lenient'
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
-    }
-
-    input:
-    path counts
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-    lf = "terminus_collapse.log"
-    """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
-    """
-}
-
 workflow DTU{ 
     take: collection
 
diff --git a/workflows/dexseq_DTU.smk b/workflows/dexseq_DTU.smk
index 79187ab8..ff8eada9 100644
--- a/workflows/dexseq_DTU.smk
+++ b/workflows/dexseq_DTU.smk
@@ -25,114 +25,7 @@ rule themall:
             # sig_u   = expand("DTU/{combo}/Tables/SigUP_DTU_DEXSEQ_{scombo}_{comparison}_results.tsv.gz", combo=combo, scombo=scombo, comparison=compstr),
             Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
 
-rule salmon_index:
-    input:  fa = REFERENCE
-    output: idx = directory(INDEX),
-            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)    
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: MAXTHREAD
-    params: mapp = COUNTBIN,
-            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
-            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
-            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
-
-
-if paired == 'paired':
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
-                r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
-                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
-        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
-
-else:
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
-        shell:  "ln -s {params.filetolink} {output.r1}"
-        
-
-if paired == 'paired':
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
-                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-else:
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-
-if runterminus:
-    rule terminus_group:
-        input:  ctsdir = rules.mapping.output.ctsdir
-        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: tpara = termpara,
-                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
-        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
-
-    rule terminus_collapse:
-        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
-                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
-        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
-
-    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
-else:
-    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-
-rule create_annotation_table:
-    input:  dir  = ctsource,
-    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: 1
-    params: dereps = lambda wildcards, input: get_reps(input.dir, config,'DTU'),
-            bins = BINS
-    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+include: "dtu_base.smk"
 
 rule run_DTU:
     input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
diff --git a/workflows/drimseq_DTU.nf b/workflows/drimseq_DTU.nf
index dbc28e22..f5b86d86 100644
--- a/workflows/drimseq_DTU.nf
+++ b/workflows/drimseq_DTU.nf
@@ -24,6 +24,8 @@ COUNTENV = 'salmon'
 
 //DTU PROCESSES
 
+include { salmon_quant; create_summary_snippet; terminus_collapse } from "dtu_base.nf"
+
 process salmon_idx{
     conda "$COUNTENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$COUNTENV"
@@ -59,68 +61,6 @@ process salmon_idx{
 
 }
 
-process salmon_quant{
-    conda "$COUNTENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
-    }
-
-    input:
-    path reads
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-
-    idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
-            stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
-            stranded = '-l ISR'
-        }else{
-            stranded = '-l IU'
-        }
-        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
-        r1 = rs[0]
-        r2 = rs[1]
-        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
-            stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
-            stranded = '-l SR'
-        }else{
-            stranded = '-l U'
-        }
-        read = reads[1]
-        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }
-}
-
 process prepare_dtu_annotation{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -186,34 +126,6 @@ process run_drimseq{
     """
 }
 
-process create_summary_snippet{
-    conda "$DTUENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'link',
-    saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
-    }
-
-    input:
-    path de
-
-    output:
-    path "*.Rmd", emit: snps
-    path "log", emit: log
-
-    script:
-    inlist = de.toString()
-    // inlist = de.toList()  // { $workflow.projectDir += "$it.code,"  }
-    """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
-    """
-}
-
 process collect_drimseq{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -230,32 +142,6 @@ process collect_drimseq{
     """
 }
 
-process terminus_collapse{
-    conda "terminus.yaml"
-    container "oras://jfallmann/monsda:terminus"
-    cpus THREADS
-	cache 'lenient'
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
-    }
-
-    input:
-    path counts
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-    lf = "terminus_collapse.log"
-    """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
-    """
-}
-
 workflow DTU{ 
     take: collection
 
diff --git a/workflows/drimseq_DTU.smk b/workflows/drimseq_DTU.smk
index db41825a..dd48d51a 100644
--- a/workflows/drimseq_DTU.smk
+++ b/workflows/drimseq_DTU.smk
@@ -35,112 +35,7 @@ rule themall:
             sig_ug   = expand("DTU/{combo}/Tables/SigUP_DTU_DRIMSEQ_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
 
-rule salmon_index:
-    input:  fa = REFERENCE
-    output: idx = directory(INDEX),
-            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: MAXTHREAD
-    params: mapp = COUNTBIN,
-            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
-            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
-            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
-
-if paired == 'paired':
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
-                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
-                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
-        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
-
-else:
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
-        shell:  "ln -s {params.filetolink} {output.r1}"
-
-if paired == 'paired':
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
-                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-else:
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-
-if runterminus:
-    rule terminus_group:
-        input:  ctsdir = rules.mapping.output.ctsdir
-        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: tpara = termpara,
-                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
-        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
-
-    rule terminus_collapse:
-        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
-                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
-        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
-
-    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
-else:
-    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-
-rule create_annotation_table:
-    input:  dir  = ctsource,
-    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: 1
-    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
-            bins = BINS
-    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+include: "dtu_base.smk"
 
 rule run_DTU:
     input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
diff --git a/workflows/dtu_base.nf b/workflows/dtu_base.nf
new file mode 100644
index 00000000..d37b1e65
--- /dev/null
+++ b/workflows/dtu_base.nf
@@ -0,0 +1,117 @@
+//DTU shared processes
+
+process salmon_quant{
+    conda "$COUNTENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$COUNTENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+
+    idx = reads[0]
+    if (PAIRED == 'paired'){
+        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+            stranded = '-l ISF'
+        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+            stranded = '-l ISR'
+        }else{
+            stranded = '-l IU'
+        }
+        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        r1 = rs[0]
+        r2 = rs[1]
+        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }else{
+        if (STRANDED == 'fr' || STRANDED == 'SF'){
+            stranded = '-l SF'
+        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+            stranded = '-l SR'
+        }else{
+            stranded = '-l U'
+        }
+        read = reads[1]
+        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
+        lf = "salmon_"+fn+".log"
+        of = fn+"/quant.sf"
+        oz = fn+"/quant.sf.gz"
+        ol = fn+"_counts.gz"
+        """
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        """
+    }
+}
+
+process create_summary_snippet{
+    conda "$DTUENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$DTUENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+    }
+
+    input:
+    path de
+
+    output:
+    path "*.Rmd", emit: snps
+    path "log", emit: log
+
+    script:
+    inlist = de.toString()
+    // inlist = de.toList()  // { $workflow.projectDir += "$it.code,"  }
+    """
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    """
+}
+
+process terminus_collapse{
+    conda "terminus.yaml"
+    container "oras://jfallmann/monsda:terminus"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+    }
+
+    input:
+    path counts
+
+    output:
+    path "*.gz", emit: counts
+    path "*.log", emit: logs
+
+    script:
+    lf = "terminus_collapse.log"
+    """
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    """
+}
diff --git a/workflows/dtu_base.smk b/workflows/dtu_base.smk
new file mode 100644
index 00000000..e759eceb
--- /dev/null
+++ b/workflows/dtu_base.smk
@@ -0,0 +1,106 @@
+rule salmon_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
+    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: MAXTHREAD
+    params: mapp = COUNTBIN,
+            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
+            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
+            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
+
+if paired == 'paired':
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
+                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
+        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
+
+else:
+    rule simulate_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
+        threads: 1
+        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
+        shell:  "ln -s {params.filetolink} {output.r1}"
+
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+else:
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
+                index = rules.salmon_index.output.idx,
+                uix = rules.salmon_index.output.uidx
+        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
+                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
+        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        conda:  ""+COUNTENV+".yaml"
+        container: "oras://jfallmann/monsda:"+COUNTENV+""
+        threads: MAXTHREAD
+        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
+                mapp=COUNTBIN,
+                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
+                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+
+
+if runterminus:
+    rule terminus_group:
+        input:  ctsdir = rules.mapping.output.ctsdir
+        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
+        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: tpara = termpara,
+                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
+        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
+
+    rule terminus_collapse:
+        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
+                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
+        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        conda:  ""+TERMINUSENV+".yaml"
+        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
+        threads: MAXTHREAD
+        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
+        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
+
+    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
+
+rule create_annotation_table:
+    input:  dir  = ctsource,
+    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
+    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    conda:  ""+COUNTENV+".yaml"
+    container: "oras://jfallmann/monsda:"+COUNTENV+""
+    threads: 1
+    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
+            bins = BINS
+    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
diff --git a/workflows/spit_DTU.nf b/workflows/spit_DTU.nf
index 65b8bf3f..cf598cb9 100644
--- a/workflows/spit_DTU.nf
+++ b/workflows/spit_DTU.nf
@@ -24,6 +24,8 @@ COUNTENV = 'salmon'
 
 //DTU PROCESSES
 
+include { salmon_quant; create_summary_snippet; terminus_collapse } from "dtu_base.nf"
+
 process salmon_idx{
     conda "$COUNTENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$COUNTENV"
@@ -59,68 +61,6 @@ process salmon_idx{
 
 }
 
-process salmon_quant{
-    conda "$COUNTENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
-    }
-
-    input:
-    path reads
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-
-    idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
-            stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
-            stranded = '-l ISR'
-        }else{
-            stranded = '-l IU'
-        }
-        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
-        r1 = rs[0]
-        r2 = rs[1]
-        fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
-            stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
-            stranded = '-l SR'
-        }else{
-            stranded = '-l U'
-        }
-        read = reads[1]
-        fn = file(reads[1]).getSimpleName().replaceAll(/\Q_trimmed\E/,"")
-        lf = "salmon_"+fn+".log"
-        of = fn+"/quant.sf"
-        oz = fn+"/quant.sf.gz"
-        ol = fn+"_counts.gz"
-        """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
-        """
-    }
-}
-
 process prepare_dtu_annotation{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -184,34 +124,6 @@ process run_spit{
     """
 }
 
-process create_summary_snippet{
-    conda "$DTUENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
-	cache 'lenient'
-    //validExitStatus 0,1
-
-    publishDir "${workflow.workDir}/../" , mode: 'link',
-    saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
-    }
-
-    input:
-    path de
-
-    output:
-    path "*.Rmd", emit: snps
-    path "log", emit: log
-
-    script:
-    inlist = de.toString()
-    // inlist = de.toList()  // { $workflow.projectDir += "$it.code,"  }
-    """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
-    """
-}
-
 process collect_spit{
     conda "$DTUENV"+".yaml"
     container "oras://jfallmann/monsda:"+"$DTUENV"
@@ -228,32 +140,6 @@ process collect_spit{
     """
 }
 
-process terminus_collapse{
-    conda "terminus.yaml"
-    container "oras://jfallmann/monsda:terminus"
-    cpus THREADS
-	cache 'lenient'
-
-    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
-    saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
-    }
-
-    input:
-    path counts
-
-    output:
-    path "*.gz", emit: counts
-    path "*.log", emit: logs
-
-    script:
-    lf = "terminus_collapse.log"
-    """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
-    """
-}
-
 workflow DTU{ 
     take: collection
 
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
index 1d09d589..4bf7bdb2 100644
--- a/workflows/spit_DTU.smk
+++ b/workflows/spit_DTU.smk
@@ -32,112 +32,7 @@ rule themall:
             sig_ug   = expand("DTU/{combo}/Tables/SigUP_DTU_SPIT_{scombo}_{comparison}_table_genes.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
 
-rule salmon_index:
-    input:  fa = REFERENCE
-    output: idx = directory(INDEX),
-            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: MAXTHREAD
-    params: mapp = COUNTBIN,
-            ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
-            decoy = f"-d {os.path.abspath(DECOY)}" if DECOY else '',
-            linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
-
-if paired == 'paired':
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
-                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1)),
-                filetolink2 = lambda w, input: "{r}".format(r=os.path.abspath(input.r2))
-        shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
-
-else:
-    rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
-        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
-        threads: 1
-        params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
-        shell:  "ln -s {params.filetolink} {output.r1}"
-
-if paired == 'paired':
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
-                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-else:
-    rule mapping:
-        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
-                index = rules.salmon_index.output.idx,
-                uix = rules.salmon_index.output.uidx
-        output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
-                ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
-        conda:  ""+COUNTENV+".yaml"
-        container: "oras://jfallmann/monsda:"+COUNTENV+""
-        threads: MAXTHREAD
-        params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
-                mapp=COUNTBIN,
-                stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
-                linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
-
-
-if runterminus:
-    rule terminus_group:
-        input:  ctsdir = rules.mapping.output.ctsdir
-        output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: tpara = termpara,
-                outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
-        shell:  "terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}"
-
-    rule terminus_collapse:
-        input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
-                dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-        output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
-        conda:  ""+TERMINUSENV+".yaml"
-        container: "oras://jfallmann/monsda:"+TERMINUSENV+""
-        threads: MAXTHREAD
-        params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
-        shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
-
-    ctsource = expand("DTU/{combo}/terminus/{file}", combo=combo, file=samplecond(SAMPLES, config))
-else:
-    ctsource = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
-
-rule create_annotation_table:
-    input:  dir  = ctsource,
-    output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
-    conda:  ""+COUNTENV+".yaml"
-    container: "oras://jfallmann/monsda:"+COUNTENV+""
-    threads: 1
-    params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
-            bins = BINS
-    shell:  "python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}"
+include: "dtu_base.smk"
 
 rule run_DTU:
     input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)

From 38ac8b34f51b83314ffc72e4b7bf7ed72f13ebea Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Sat, 4 Jul 2026 20:03:14 +0200
Subject: [PATCH 07/80] claude streamline of output paths between smk and nf
 where fixes where needed

---
 MONSDA/Workflows.py      |  6 +++---
 workflows/alevinfry.nf   |  4 ++--
 workflows/fastqc_raw.smk | 24 ++++++++++++------------
 workflows/kallisto.nf    |  4 ++--
 workflows/oarfish.nf     |  4 ++--
 workflows/salmon.nf      |  8 ++++----
 workflows/simpleaf.nf    |  4 ++--
 7 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 293206e0..9575e4f3 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -1495,10 +1495,10 @@ def rulethemall(subworkflows, config, loglevel, condapath, logfix, combo=""):
         else 'rule themall:\n\tinput:\texpand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"])'
     )
     allqc = 'expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
-    allrawqc = 'rule themall:\n\tinput:\texpand("QC/Multi{combo}{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
-    alltrimqc = 'rule themall:\n\tinput:\texpand("QC/Multi{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
+    allrawqc = 'rule themall:\n\tinput:\texpand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
+    alltrimqc = 'rule themall:\n\tinput:\texpand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
     alltrim = 'rule themall:\n\tinput: expand("TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz", combo=combo, file=samplecond(SAMPLES, config), read=["R1","R2"]) if paired == \'paired\' else expand("TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz", combo=combo, file=samplecond(SAMPLES, config))'
-    alldedupqc = 'rule themall:\n\tinput:\texpand("QC/Multi{combo}/{condition}/multiqc_report.html", combo=combo, condition=str.join(os.sep, conditiononly(SAMPLES[0], config)))'
+    alldedupqc = 'rule themall:\n\tinput:\texpand("QC/Multi/{combo}/{condition}/multiqc_report.html", combo=combo, condition=str.join(os.sep, conditiononly(SAMPLES[0], config)))'
     alldedup = 'rule themall:\n\tinput: expand("DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz", combo=combo, file=samplecond(SAMPLES, config), read=["R1","R2"]) if paired == \'paired\' else expand("DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz", combo=combo, file=samplecond(SAMPLES, config))'
     alltrimdedupqc = 'rule themall:\n\tinput:\texpand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)'
 
diff --git a/workflows/alevinfry.nf b/workflows/alevinfry.nf
index 9ce314b0..6bbc9efd 100644
--- a/workflows/alevinfry.nf
+++ b/workflows/alevinfry.nf
@@ -36,8 +36,8 @@ process alevinfry_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/alevinfry/${CONDITION}/COUNTING/${file(filename).getName()}"
-        else                                    "COUNTS/${SCOMBO}/alevinfry/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/fastqc_raw.smk b/workflows/fastqc_raw.smk
index 1fe7ab37..05efccc4 100644
--- a/workflows/fastqc_raw.smk
+++ b/workflows/fastqc_raw.smk
@@ -4,8 +4,8 @@ if paired == 'paired':
     log.info('Running paired mode QC')
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
-        output: o1 = report("QC{combo}{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS{combo}{rawfile}_fastqc_{read}_raw.log"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -14,10 +14,10 @@ if paired == 'paired':
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi{combo}{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi{combo}{condition}/tmp"),
-                lst = "QC/Multi{combo}{condition}/qclist_raw.txt"
-        log:    "LOGS{combo}{condition}_multiqc_raw.log"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -27,8 +27,8 @@ if paired == 'paired':
 else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
-        output: o1 = report("QC{combo}{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS{combo}{rawfile}_fastqc_raw.log"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -37,10 +37,10 @@ else:
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo)
-        output: html = report("QC/Multi{combo}{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi{combo}{condition}/tmp"),
-                lst = "QC/Multi{combo}{condition}/qclist_raw.txt"
-        log:    "LOGS{combo}{condition}_multiqc_raw.log"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/kallisto.nf b/workflows/kallisto.nf
index 2a7425ef..2b3ecef1 100644
--- a/workflows/kallisto.nf
+++ b/workflows/kallisto.nf
@@ -96,8 +96,8 @@ process kallisto_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/kallisto/${CONDITION}/COUNTING/${file(filename).getName()}"
-        else                                    "COUNTS/${SCOMBO}/kallisto/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
index d40851dc..5678bcda 100644
--- a/workflows/oarfish.nf
+++ b/workflows/oarfish.nf
@@ -17,8 +17,8 @@ process oarfish_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/oarfish/${CONDITION}/COUNTING/${file(filename).getName()}"
-        else                                    "COUNTS/${SCOMBO}/oarfish/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index a63f1576..fc7eb919 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -98,9 +98,9 @@ process salmon_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
 
-        else                                    "COUNTS/${SCOMBO}/salmon/${CONDITION}/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
@@ -161,8 +161,8 @@ process salmon_quant_bam{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/COUNTING/${file(filename).getName()}"
-        else                                    "COUNTS/${SCOMBO}/salmon/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/simpleaf.nf b/workflows/simpleaf.nf
index bd6ed619..2e5f92f3 100644
--- a/workflows/simpleaf.nf
+++ b/workflows/simpleaf.nf
@@ -52,8 +52,8 @@ process simpleaf_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/simpleaf/${CONDITION}/COUNTING/${file(filename).getName()}"
-        else                                    "COUNTS/${SCOMBO}/simpleaf/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:

From 4fe61f54765f5974898b9e8b83130d6cab305ce2 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Sun, 5 Jul 2026 20:37:59 +0200
Subject: [PATCH 08/80] Claude upgraded to deal with breaking changes of
 nextflow v26. Updated param assignment to pass strict syntax parser. Fixed
 tests to brevent breaks after fixing bugs in kallisto/salmon nf runs

---
 MONSDA/Workflows.py                           | 197 +++++++++++-
 ...imgalore-picard-star_DTU_dexseq_subflow.nf | 226 ++++++-------
 ...mgalore-picard-star_DTU_drimseq_subflow.nf | 226 ++++++-------
 ...trimgalore-picard-star_DTU_spit_subflow.nf | 224 ++++++-------
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 280 ++++++++--------
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 299 +++++++++---------
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 280 ++++++++--------
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 299 +++++++++---------
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 280 ++++++++--------
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 299 +++++++++---------
 workflows/countreads.nf                       |   5 +-
 workflows/header.nf                           |   5 +-
 workflows/kallisto.nf                         |   6 +-
 workflows/salmon.nf                           |   6 +-
 14 files changed, 1418 insertions(+), 1214 deletions(-)

diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 9575e4f3..82125342 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -87,8 +87,197 @@ def _fix_oras(line: str) -> str:
     return _rewrite_oras(line)
 
 
+_NF_KW = ("def ", "process", "workflow", "include", "params", "nextflow")
+
+_NF_PFX = "g"
+
+
+def _nf_is_channel(rhs_list):
+    return any("Channel." in r for r in rhs_list)
+
+
+def _nf_rw(text, scalars, channels, ex_s=None, ex_c=None):
+    """Rewrite bare references to global names: scalars -> params.gNAME,
+    channels -> NAME(). Interpolated forms handled as well."""
+    s_active = set(scalars) - ({ex_s} if ex_s else set())
+    c_active = set(channels) - ({ex_c} if ex_c else set())
+    alln = s_active | c_active
+    if not alln:
+        return text
+
+    def repl(name, interp):
+        if name in c_active:
+            return ("${" + name + "()}") if interp else (name + "()")
+        return (
+            ("${params." + _NF_PFX + name + "}")
+            if interp
+            else ("params." + _NF_PFX + name)
+        )
+
+    alt = "|".join(sorted(map(re.escape, alln), key=len, reverse=True))
+    text = re.sub(r"\$\{(" + alt + r")\}", lambda m: repl(m.group(1), True), text)
+    text = re.sub(r"\$(" + alt + r")(?![\w(])", lambda m: repl(m.group(1), True), text)
+    text = re.sub(
+        r"(?<![\w.$])(" + alt + r")\b(?!\s*=(?!=))(?!\s*\()",
+        lambda m: repl(m.group(1), False),
+        text,
+    )
+    return text
+
+
+def _nf_rewrite_samples_ch(body, scalars, channels):
+    """Rewrite the header global samples_ch to samples_ch(), but skip blocks
+    that locally reassign samples_ch (process/workflow bodies)."""
+    lines = body.split("\n")
+    out = []
+    i = 0
+    n = len(lines)
+    while i < n:
+        ln = lines[i]
+        if re.match(r"^(process|workflow)\b.*\{\s*$", ln):
+            block = [ln]
+            i += 1
+            while i < n and not re.match(r"^\}", lines[i]):
+                block.append(lines[i])
+                i += 1
+            if i < n:
+                block.append(lines[i])
+                i += 1
+            btext = "\n".join(block)
+            if not re.search(r"^\s+samples_ch\s*=", btext, re.M):
+                btext = _nf_rw(btext, set(), {"samples_ch"})
+            out.append(btext)
+        else:
+            out.append(_nf_rw(ln, set(), {"samples_ch"}))
+            i += 1
+    return "\n".join(out)
+
+
+def nf_paramize(content):
+    """Rewrite col-0 global scalar assignments to params.NAME definitions
+    (folding multiple/derived assignments into a single definition) and
+    channel globals to getter functions, so the generated Nextflow file
+    parses and runs under the strict (default) Nextflow parser."""
+    content = re.sub(r"(\})[ \t]+(process\b|workflow\b)", r"\1\n\2", content)
+    lines = content.split("\n")
+    n = len(lines)
+    assign_re = re.compile(r"^([A-Za-z_]\w*)\s*=(?!=)\s*(.*)$")
+    order = []
+    assigns = {}
+    drop = set()
+    ifblocks = []
+    ifnames = []
+    i = 0
+    while i < n:
+        ln = lines[i]
+        if ln[:1] not in ("", " ", "\t"):
+            if ln.startswith(_NF_KW) or ln[:1] in ("}", ")", "/", "#", "@"):
+                i += 1
+                continue
+            m = assign_re.match(ln)
+            if m:
+                name, rhs = m.group(1), m.group(2)
+                assigns.setdefault(name, [])
+                if name not in order:
+                    order.append(name)
+                assigns[name].append(rhs)
+                drop.add(i)
+            elif re.match(r"^if\s*\(", ln):
+                start = i
+                buf = [ln]
+                depth = ln.count("{") - ln.count("}")
+                i += 1
+                while i < n and depth > 0:
+                    buf.append(lines[i])
+                    depth += lines[i].count("{") - lines[i].count("}")
+                    i += 1
+                for k in range(start, i):
+                    drop.add(k)
+                nm = None
+                for bl in buf:
+                    mm = re.match(r"^\s*([A-Za-z_]\w*)\s*=(?!=)", bl)
+                    if mm:
+                        nm = mm.group(1)
+                        break
+                if nm:
+                    ifblocks.append((nm, buf))
+                    ifnames.append(nm)
+                continue
+            else:
+                drop.add(i)
+        i += 1
+
+    channels = set(nm for nm in order if _nf_is_channel(assigns[nm]))
+    scalars = (set(order) - channels) | set(ifnames)
+
+    defs = []
+    for name in order:
+        rhs_list = assigns[name]
+        if name in channels:
+            block_body = []
+            for k, rhs in enumerate(rhs_list):
+                r = _nf_rw(rhs, scalars, channels, ex_c=name)
+                pre = "    def %s = %s" if k == 0 else "    %s = %s"
+                block_body.append(pre % (name, r))
+            block_body.append("    return %s" % name)
+            defs.append("def %s(){\n%s\n}" % (name, "\n".join(block_body)))
+        elif len(rhs_list) == 1:
+            r = _nf_rw(rhs_list[0], scalars, channels, ex_s=name)
+            defs.append("params.%s%s = %s" % (_NF_PFX, name, r))
+        else:
+            block_body = []
+            for k, rhs in enumerate(rhs_list):
+                r = _nf_rw(rhs, scalars, channels, ex_s=name)
+                pre = "def %s = %s" if k == 0 else "%s = %s"
+                block_body.append(pre % (name, r))
+            block_body.append("return %s" % name)
+            defs.append(
+                "params.%s%s = { %s }()" % (_NF_PFX, name, "; ".join(block_body))
+            )
+
+    for nm, buf in ifblocks:
+        tb = []
+        for bl in buf:
+            bl2 = re.sub(r"^(\s*)" + re.escape(nm) + r"\s*=\s*", r"\1return ", bl)
+            tb.append(bl2)
+        block = "\n".join(tb)
+        block = _nf_rw(block, scalars, channels, ex_s=nm)
+        defs.append("params.%s%s = {\n%s\n}()" % (_NF_PFX, nm, block))
+
+    kept = [ln for idx, ln in enumerate(lines) if idx not in drop]
+    body = "\n".join(kept)
+
+    body = _nf_rw(body, scalars, channels - {"samples_ch"})
+    if "samples_ch" in channels:
+        body = _nf_rewrite_samples_ch(body, scalars, channels)
+
+    def_txt = "\n".join(defs)
+    kl = body.split("\n")
+    out_lines = []
+    inserted = False
+    j = 0
+    while j < len(kl):
+        out_lines.append(kl[j])
+        if not inserted and kl[j].startswith("def get_always"):
+            k = j
+            while k < len(kl) and not kl[k].startswith("}"):
+                k += 1
+            for x in range(j + 1, k + 1):
+                out_lines.append(kl[x])
+            out_lines.append(def_txt)
+            j = k + 1
+            inserted = True
+            continue
+        j += 1
+    if not inserted:
+        out_lines = [def_txt] + kl
+    return "\n".join(out_lines)
+
+
 def _write_workflow(filepath, content):
     """Write workflow file with ORAS registry fix applied."""
+    if str(filepath).endswith(".nf"):
+        content = nf_paramize(content)
     content = _rewrite_oras(content)
     write_if_different(filepath, content)
 
@@ -3304,7 +3493,8 @@ def nf_make_post(
 
                 # Append subwork suffix for all applicable postprocess workflows
                 toolenv_orig = toolenv
-                toolenv = toolenv + "_" + subwork
+                if subwork in ["DE", "DEU", "DAS", "DTU"] and toolbin not in ["deseq", "diego"]:
+                    toolenv = toolenv + "_" + subwork
                 sconf[subwork + "ENV"] = toolenv
                 sconf[subwork + "BIN"] = toolbin
                 subsamples = mp.get_samples(sconf)
@@ -3437,8 +3627,9 @@ def nf_make_post(
             subjobs = list()
 
             toolenv, toolbin = map(str, listoftools[a])
-            # Append subwork suffix for all postprocessing workflows
-            toolenv = toolenv + "_" + subwork
+            # Append subwork suffix for all applicable postprocess workflows
+            if subwork in ["DE", "DEU", "DAS", "DTU"] and toolbin not in ["deseq", "diego"]:
+                toolenv = toolenv + "_" + subwork
 
             log.debug(logid + "toolenv: " + str(toolenv))
             sconf[subwork + "ENV"] = toolenv
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
index bc3b92bd..facd7d71 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -1,70 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = { def BINS = get_always('BINS'); BINS = get_always('BINS'); return BINS }()
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gDTUENV = get_always('DTUENV')
+params.gDTUBIN = get_always('DTUBIN')
+params.gDTUREF = get_always('DTUREF')
+params.gDTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+params.gDTUANNO = get_always('DTUANNO')
+params.gDTUDECOY = get_always('DTUDECOY')
+params.gDTUIDX = get_always('DTUIDX')
+params.gDTUUIDX = get_always('DTUUIDX')
+params.gDTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+params.gIDXPARAMS = get_always('dexseq_DTU_params_INDEX') ?: ''
+params.gCOUNTPARAMS = get_always('dexseq_DTU_params_COUNT') ?: ''
+params.gDTUPARAMS = get_always('dexseq_DTU_params_DTU') ?: ''
+params.gRUNTERMINUS = get_always('dexseq_DTU_params_TERMINUS') ?: ''
+params.gDTUREPS = get_always('DTUREPS') ?: ''
+params.gDTUCOMP = get_always('DTUCOMP') ?: ''
+params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
+params.gPVAL = get_always('DTUPVAL') ?: ''
+params.gLFC = get_always('DTULFC') ?: ''
+params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gCOUNTBIN = 'salmon'
+params.gCOUNTENV = 'salmon'
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-BINS = get_always('BINS')
-DTUENV = get_always('DTUENV')
-DTUBIN = get_always('DTUBIN')
-DTUREF = get_always('DTUREF')
-DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
-DTUANNO = get_always('DTUANNO')
-DTUDECOY = get_always('DTUDECOY')
-DTUIDX = get_always('DTUIDX')
-DTUUIDX = get_always('DTUUIDX')
-DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
-IDXPARAMS = get_always('dexseq_DTU_params_INDEX') ?: ''
-COUNTPARAMS = get_always('dexseq_DTU_params_COUNT') ?: ''
-DTUPARAMS = get_always('dexseq_DTU_params_DTU') ?: ''
-RUNTERMINUS = get_always('dexseq_DTU_params_TERMINUS') ?: ''
-DTUREPS = get_always('DTUREPS') ?: ''
-DTUCOMP = get_always('DTUCOMP') ?: ''
-DTUCOMPS = get_always('DTUCOMPS') ?: ''
-PVAL = get_always('DTUPVAL') ?: ''
-LFC = get_always('DTULFC') ?: ''
-PCOMBO = get_always('COMBO') ?: 'none'
-COUNTBIN = 'salmon'
-COUNTENV = 'salmon'
 process salmon_quant{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
     path reads
@@ -73,10 +77,10 @@ process salmon_quant{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+    if (params.gPAIRED == 'paired'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'ISF'){
             stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'ISR'){
             stranded = '-l ISR'
         }else{
             stranded = '-l IU'
@@ -90,12 +94,12 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'SF'){
             stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'SR'){
             stranded = '-l SR'
         }else{
             stranded = '-l U'
@@ -107,18 +111,18 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }
 }
 process create_summary_snippet{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
         else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
     }
     input:
@@ -129,18 +133,18 @@ process create_summary_snippet{
     script:
     inlist = de.toString()
     """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    touch log; python3 ${params.gBINS}/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env ${params.gDTUENV} --loglevel DEBUG 2>> log
     """
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
     container "oras://docker.io/jfallmann/monsda:terminus"
-    cpus THREADS
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
     path counts
@@ -150,69 +154,69 @@ process terminus_collapse{
     script:
     lf = "terminus_collapse.log"
     """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group ${params.gRUNTERMINUS} -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
     """
 }
 process salmon_idx{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/dexseq_index.log"
-        else if (filename == "dexseq.idx")            "$DTUIDX"
-        else                                          "$DTUUIDX"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/dexseq_index.log"
+        else if (filename == "dexseq.idx")            "${params.gDTUIDX}"
+        else                                          "${params.gDTUUIDX}"
     }
     input:
     path genome
     output:
-     path "$DTUUIDXNAME", emit: idx
+     path "${params.gDTUUIDXNAME}", emit: idx
     path "*.log", emit: idxlog
     path "*.idx", emit: tmpidx
     script:    
     gen =  genome.getName()
-    if (DTUDECOY){
-        decoy = "-d "+"${DTUDECOY}" 
+    if (params.gDTUDECOY){
+        decoy = "-d "+"${params.gDTUDECOY}" 
     }else{
         decoy = ''
     }
     """
-    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME dexseq.idx
+    ${params.gCOUNTBIN} index ${params.gIDXPARAMS} $decoy -p ${task.cpus} -t $gen -i ${params.gDTUUIDXNAME} &> index.log && ln -fs ${params.gDTUUIDXNAME} dexseq.idx
     """
 }
 process prepare_dtu_annotation{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_dexseq_annotation.log"
+        if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_dexseq_annotation.log"
     }
     output:
     path "*.gz", emit: anno
     path "*.log", emit: log
     script:     
-    ca = COMBO+"_ANNOTATION.gz"
+    ca = params.gCOMBO+"_ANNOTATION.gz"
     ol = "create_DTU_table.log"
     """
-    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    mkdir -p TMP; ${params.gBINS}/Analysis/build_DTU_table.py ${params.gDTUREPS} --anno $ca --loglevel DEBUG --nextflow 2>> $ol
     """
 }
 process run_dexseq{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
-        else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/DEXSeqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
-        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_dexseq.log"
+        if (filename.indexOf("_table") > 0)      "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf(".html") > 0)      "DTU/${params.gSCOMBO}/DEXSeqReport_${params.gCOMBO}_${params.gDTUCOMP}/${file(filename).getName()}"
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_dexseq.log"
     }
     input:path counts
     path anno
@@ -224,19 +228,19 @@ process run_dexseq{
     path "*SESSION.gz", emit: session
     path "log", emit: log
     script:    
-    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
-    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
-    comp = "${DTUCOMP}".split(':')[0]
-    dparams = "'${DTUPARAMS}'"
+    outdir = "DTU"+File.separatorChar+"${params.gSCOMBO}"
+    bin = "${params.gBINS}"+File.separatorChar+"${params.gDTUBIN}"
+    comp = "${params.gDTUCOMP}".split(':')[0]
+    dparams = "'${params.gDTUPARAMS}'"
     """
     mkdir -p Figures Tables
-    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . ${params.gDTUCOMP} ${params.gPCOMBO} ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy() && ln -f Figures/* .
     """
 }
 process collect_dexseq{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     input:
     path de
@@ -248,31 +252,31 @@ process collect_dexseq{
 workflow DTU{ 
     take: collection
     main:
-    TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+    TRIMSAMPLES = params.gLONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
-    annofile = Channel.fromPath(DTUANNO)
-    checkidx = file(DTUIDX)
+    annofile = Channel.fromPath(params.gDTUANNO)
+    checkidx = file(params.gDTUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(DTUUIDX)
-        if (PAIRED == 'paired'){
+        idxfile = Channel.fromPath(params.gDTUUIDX)
+        if (params.gPAIRED == 'paired'){
             salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
         }        
     }
     else{
-        genomefile = Channel.fromPath(DTUREF)
+        genomefile = Channel.fromPath(params.gDTUREF)
         salmon_idx(genomefile)
-        if (PAIRED == 'paired'){
+        if (params.gPAIRED == 'paired'){
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
         }
     }
     prepare_dtu_annotation()
-    if (RUNTERMINUS?.length() > 0){
+    if (params.gRUNTERMINUS?.length() > 0){
         terminus_collapse(salmon_quant.out.counts.collect())
         dtucounts = terminus_collapse.out.counts
     }
@@ -291,6 +295,6 @@ workflow DTU{
 
 
 workflow {
-    DTU(dummy)
+    DTU(dummy())
 }
 
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
index 0e6684ea..242c43fc 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -1,70 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = { def BINS = get_always('BINS'); BINS = get_always('BINS'); return BINS }()
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gDTUENV = get_always('DTUENV')
+params.gDTUBIN = get_always('DTUBIN')
+params.gDTUREF = get_always('DTUREF')
+params.gDTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+params.gDTUANNO = get_always('DTUANNO')
+params.gDTUDECOY = get_always('DTUDECOY')
+params.gDTUIDX = get_always('DTUIDX')
+params.gDTUUIDX = get_always('DTUUIDX')
+params.gDTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+params.gIDXPARAMS = get_always('drimseq_DTU_params_INDEX') ?: ''
+params.gCOUNTPARAMS = get_always('drimseq_DTU_params_COUNT') ?: ''
+params.gDTUPARAMS = get_always('drimseq_DTU_params_DTU') ?: ''
+params.gRUNTERMINUS = get_always('drimseq_DTU_params_TERMINUS') ?: ''
+params.gDTUREPS = get_always('DTUREPS') ?: ''
+params.gDTUCOMP = get_always('DTUCOMP') ?: ''
+params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
+params.gPVAL = get_always('DTUPVAL') ?: ''
+params.gLFC = get_always('DTULFC') ?: ''
+params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gCOUNTBIN = 'salmon'
+params.gCOUNTENV = 'salmon'
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-BINS = get_always('BINS')
-DTUENV = get_always('DTUENV')
-DTUBIN = get_always('DTUBIN')
-DTUREF = get_always('DTUREF')
-DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
-DTUANNO = get_always('DTUANNO')
-DTUDECOY = get_always('DTUDECOY')
-DTUIDX = get_always('DTUIDX')
-DTUUIDX = get_always('DTUUIDX')
-DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
-IDXPARAMS = get_always('drimseq_DTU_params_INDEX') ?: ''
-COUNTPARAMS = get_always('drimseq_DTU_params_COUNT') ?: ''
-DTUPARAMS = get_always('drimseq_DTU_params_DTU') ?: ''
-RUNTERMINUS = get_always('drimseq_DTU_params_TERMINUS') ?: ''
-DTUREPS = get_always('DTUREPS') ?: ''
-DTUCOMP = get_always('DTUCOMP') ?: ''
-DTUCOMPS = get_always('DTUCOMPS') ?: ''
-PVAL = get_always('DTUPVAL') ?: ''
-LFC = get_always('DTULFC') ?: ''
-PCOMBO = get_always('COMBO') ?: 'none'
-COUNTBIN = 'salmon'
-COUNTENV = 'salmon'
 process salmon_quant{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
     path reads
@@ -73,10 +77,10 @@ process salmon_quant{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+    if (params.gPAIRED == 'paired'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'ISF'){
             stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'ISR'){
             stranded = '-l ISR'
         }else{
             stranded = '-l IU'
@@ -90,12 +94,12 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'SF'){
             stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'SR'){
             stranded = '-l SR'
         }else{
             stranded = '-l U'
@@ -107,18 +111,18 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }
 }
 process create_summary_snippet{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
         else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
     }
     input:
@@ -129,18 +133,18 @@ process create_summary_snippet{
     script:
     inlist = de.toString()
     """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    touch log; python3 ${params.gBINS}/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env ${params.gDTUENV} --loglevel DEBUG 2>> log
     """
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
     container "oras://docker.io/jfallmann/monsda:terminus"
-    cpus THREADS
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
     path counts
@@ -150,69 +154,69 @@ process terminus_collapse{
     script:
     lf = "terminus_collapse.log"
     """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group ${params.gRUNTERMINUS} -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
     """
 }
 process salmon_idx{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/drimseq_index.log"
-        else if (filename == "drimseq.idx")           "$DTUIDX"
-        else                                          "$DTUUIDX"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/drimseq_index.log"
+        else if (filename == "drimseq.idx")           "${params.gDTUIDX}"
+        else                                          "${params.gDTUUIDX}"
     }
     input:
     path genome
     output:
-     path "$DTUUIDXNAME", emit: idx
+     path "${params.gDTUUIDXNAME}", emit: idx
     path "*.log", emit: idxlog
     path "*.idx", emit: tmpidx
     script:    
     gen =  genome.getName()
-    if (DTUDECOY){
-        decoy = "-d "+"${DTUDECOY}" 
+    if (params.gDTUDECOY){
+        decoy = "-d "+"${params.gDTUDECOY}" 
     }else{
         decoy = ''
     }
     """
-    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME drimseq.idx
+    ${params.gCOUNTBIN} index ${params.gIDXPARAMS} $decoy -p ${task.cpus} -t $gen -i ${params.gDTUUIDXNAME} &> index.log && ln -fs ${params.gDTUUIDXNAME} drimseq.idx
     """
 }
 process prepare_dtu_annotation{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_drimseq_annotation.log"
+        if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_drimseq_annotation.log"
     }
     output:
     path "*.gz", emit: anno
     path "*.log", emit: log
     script:     
-    ca = COMBO+"_ANNOTATION.gz"
+    ca = params.gCOMBO+"_ANNOTATION.gz"
     ol = "create_DTU_table.log"
     """
-    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    mkdir -p TMP; ${params.gBINS}/Analysis/build_DTU_table.py ${params.gDTUREPS} --anno $ca --loglevel DEBUG --nextflow 2>> $ol
     """
 }
 process run_drimseq{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
-        else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/drimseqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
-        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_drimseq.log"
+        if (filename.indexOf("_table") > 0)      "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf(".html") > 0)      "DTU/${params.gSCOMBO}/drimseqReport_${params.gCOMBO}_${params.gDTUCOMP}/${file(filename).getName()}"
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_drimseq.log"
     }
     input:
     path counts
@@ -225,19 +229,19 @@ process run_drimseq{
     path "*SESSION.gz", emit: session
     path "log", emit: log
     script:    
-    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
-    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
-    comp = "${DTUCOMP}".split(':')[0]
-    dparams = "'${DTUPARAMS}'"
+    outdir = "DTU"+File.separatorChar+"${params.gSCOMBO}"
+    bin = "${params.gBINS}"+File.separatorChar+"${params.gDTUBIN}"
+    comp = "${params.gDTUCOMP}".split(':')[0]
+    dparams = "'${params.gDTUPARAMS}'"
     """
     mkdir -p Figures Tables
-    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . ${params.gDTUCOMP} ${params.gPCOMBO} ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy() && ln -f Figures/* .
     """
 }
 process collect_drimseq{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     input:
     path de
@@ -249,31 +253,31 @@ process collect_drimseq{
 workflow DTU{ 
     take: collection
     main:
-    TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+    TRIMSAMPLES = params.gLONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
-    annofile = Channel.fromPath(DTUANNO)
-    checkidx = file(DTUIDX)
+    annofile = Channel.fromPath(params.gDTUANNO)
+    checkidx = file(params.gDTUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(DTUUIDX)
-        if (PAIRED == 'paired'){
+        idxfile = Channel.fromPath(params.gDTUUIDX)
+        if (params.gPAIRED == 'paired'){
             salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
         }        
     }
     else{
-        genomefile = Channel.fromPath(DTUREF)
+        genomefile = Channel.fromPath(params.gDTUREF)
         salmon_idx(genomefile)
-        if (PAIRED == 'paired'){
+        if (params.gPAIRED == 'paired'){
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
         }
     }
     prepare_dtu_annotation()
-    if (RUNTERMINUS?.length() > 0){
+    if (params.gRUNTERMINUS?.length() > 0){
         terminus_collapse(salmon_quant.out.counts.collect())
         dtucounts = terminus_collapse.out.counts
     }
@@ -292,6 +296,6 @@ workflow DTU{
 
 
 workflow {
-    DTU(dummy)
+    DTU(dummy())
 }
 
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
index a68c9776..36f794d3 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -1,70 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = { def BINS = get_always('BINS'); BINS = get_always('BINS'); return BINS }()
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gDTUENV = get_always('DTUENV')
+params.gDTUBIN = get_always('DTUBIN')
+params.gDTUREF = get_always('DTUREF')
+params.gDTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
+params.gDTUANNO = get_always('DTUANNO')
+params.gDTUDECOY = get_always('DTUDECOY')
+params.gDTUIDX = get_always('DTUIDX')
+params.gDTUUIDX = get_always('DTUUIDX')
+params.gDTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
+params.gIDXPARAMS = get_always('spit_DTU_params_INDEX') ?: ''
+params.gCOUNTPARAMS = get_always('spit_DTU_params_COUNT') ?: ''
+params.gDTUPARAMS = get_always('spit_DTU_params_DTU') ?: ''
+params.gRUNTERMINUS = get_always('spit_DTU_params_TERMINUS') ?: ''
+params.gDTUREPS = get_always('DTUREPS') ?: ''
+params.gDTUCOMP = get_always('DTUCOMP') ?: ''
+params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
+params.gPVAL = get_always('DTUPVAL') ?: ''
+params.gLFC = get_always('DTULFC') ?: ''
+params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gCOUNTBIN = 'salmon'
+params.gCOUNTENV = 'salmon'
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-BINS = get_always('BINS')
-DTUENV = get_always('DTUENV')
-DTUBIN = get_always('DTUBIN')
-DTUREF = get_always('DTUREF')
-DTUREFDIR = "${workflow.workDir}/../"+get_always('DTUREFDIR')
-DTUANNO = get_always('DTUANNO')
-DTUDECOY = get_always('DTUDECOY')
-DTUIDX = get_always('DTUIDX')
-DTUUIDX = get_always('DTUUIDX')
-DTUUIDXNAME = get_always('DTUUIDXNAME')+'.idx'
-IDXPARAMS = get_always('spit_DTU_params_INDEX') ?: ''
-COUNTPARAMS = get_always('spit_DTU_params_COUNT') ?: ''
-DTUPARAMS = get_always('spit_DTU_params_DTU') ?: ''
-RUNTERMINUS = get_always('spit_DTU_params_TERMINUS') ?: ''
-DTUREPS = get_always('DTUREPS') ?: ''
-DTUCOMP = get_always('DTUCOMP') ?: ''
-DTUCOMPS = get_always('DTUCOMPS') ?: ''
-PVAL = get_always('DTUPVAL') ?: ''
-LFC = get_always('DTULFC') ?: ''
-PCOMBO = get_always('COMBO') ?: 'none'
-COUNTBIN = 'salmon'
-COUNTENV = 'salmon'
 process salmon_quant{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
     path reads
@@ -73,10 +77,10 @@ process salmon_quant{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
-        if (STRANDED == 'fr' || STRANDED == 'ISF'){
+    if (params.gPAIRED == 'paired'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'ISF'){
             stranded = '-l ISF'
-        }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'ISR'){
             stranded = '-l ISR'
         }else{
             stranded = '-l IU'
@@ -90,12 +94,12 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }else{
-        if (STRANDED == 'fr' || STRANDED == 'SF'){
+        if (params.gSTRANDED == 'fr' || params.gSTRANDED == 'SF'){
             stranded = '-l SF'
-        }else if (STRANDED == 'rf' || STRANDED == 'SR'){
+        }else if (params.gSTRANDED == 'rf' || params.gSTRANDED == 'SR'){
             stranded = '-l SR'
         }else{
             stranded = '-l U'
@@ -107,18 +111,18 @@ process salmon_quant{
         oz = fn+"/quant.sf.gz"
         ol = fn+"_counts.gz"
         """
-        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        ${params.gCOUNTBIN} ${params.gCOUNTPARAMS} quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
         """
     }
 }
 process create_summary_snippet{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
+        if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
         else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
     }
     input:
@@ -129,18 +133,18 @@ process create_summary_snippet{
     script:
     inlist = de.toString()
     """
-    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    touch log; python3 ${params.gBINS}/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env ${params.gDTUENV} --loglevel DEBUG 2>> log
     """
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
     container "oras://docker.io/jfallmann/monsda:terminus"
-    cpus THREADS
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
-        else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
     path counts
@@ -150,68 +154,68 @@ process terminus_collapse{
     script:
     lf = "terminus_collapse.log"
     """
-    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group ${params.gRUNTERMINUS} -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
     """
 }
 process salmon_idx{
-    conda "<REPO>/envs/$COUNTENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$COUNTENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/spit_index.log"
-        else if (filename == "spit.idx")           "$DTUIDX"
-        else                                          "$DTUUIDX"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/spit_index.log"
+        else if (filename == "spit.idx")           "${params.gDTUIDX}"
+        else                                          "${params.gDTUUIDX}"
     }
     input:
     path genome
     output:
-     path "$DTUUIDXNAME", emit: idx
+     path "${params.gDTUUIDXNAME}", emit: idx
     path "*.log", emit: idxlog
     path "*.idx", emit: tmpidx
     script:    
     gen =  genome.getName()
-    if (DTUDECOY){
-        decoy = "-d "+"${DTUDECOY}" 
+    if (params.gDTUDECOY){
+        decoy = "-d "+"${params.gDTUDECOY}" 
     }else{
         decoy = ''
     }
     """
-    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME spit.idx
+    ${params.gCOUNTBIN} index ${params.gIDXPARAMS} $decoy -p ${task.cpus} -t $gen -i ${params.gDTUUIDXNAME} &> index.log && ln -fs ${params.gDTUUIDXNAME} spit.idx
     """
 }
 process prepare_dtu_annotation{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_spit_annotation.log"
+        if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_spit_annotation.log"
     }
     output:
     path "*.gz", emit: anno
     path "*.log", emit: log
     script:     
-    ca = COMBO+"_ANNOTATION.gz"
+    ca = params.gCOMBO+"_ANNOTATION.gz"
     ol = "create_DTU_table.log"
     """
-    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    mkdir -p TMP; ${params.gBINS}/Analysis/build_DTU_table.py ${params.gDTUREPS} --anno $ca --loglevel DEBUG --nextflow 2>> $ol
     """
 }
 process run_spit{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
-        else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_spit.log"
+        if (filename.indexOf("_table") > 0)      "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
+        else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
+        else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_spit.log"
     }
     input:
     path counts
@@ -223,19 +227,19 @@ process run_spit{
     path "*SESSION.gz", emit: session
     path "log", emit: log
     script:    
-    outdir = "DTU"+File.separatorChar+"${SCOMBO}"
-    bin = "${BINS}"+File.separatorChar+"${DTUBIN}"
-    comp = "${DTUCOMP}".split(':')[0]
-    dparams = "'${DTUPARAMS}'"
+    outdir = "DTU"+File.separatorChar+"${params.gSCOMBO}"
+    bin = "${params.gBINS}"+File.separatorChar+"${params.gDTUBIN}"
+    comp = "${params.gDTUCOMP}".split(':')[0]
+    dparams = "'${params.gDTUPARAMS}'"
     """
     mkdir -p Figures Tables
-    python3 $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    python3 $bin $anno $ref . ${params.gDTUCOMP} ${params.gPCOMBO} ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy() && ln -f Figures/* .
     """
 }
 process collect_spit{
-    conda "<REPO>/envs/$DTUENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DTUENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     input:
     path de
@@ -247,31 +251,31 @@ process collect_spit{
 workflow DTU{ 
     take: collection
     main:
-    TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+    TRIMSAMPLES = params.gLONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
-    annofile = Channel.fromPath(DTUANNO)
-    checkidx = file(DTUIDX)
+    annofile = Channel.fromPath(params.gDTUANNO)
+    checkidx = file(params.gDTUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(DTUUIDX)
-        if (PAIRED == 'paired'){
+        idxfile = Channel.fromPath(params.gDTUUIDX)
+        if (params.gPAIRED == 'paired'){
             salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
         }        
     }
     else{
-        genomefile = Channel.fromPath(DTUREF)
+        genomefile = Channel.fromPath(params.gDTUREF)
         salmon_idx(genomefile)
-        if (PAIRED == 'paired'){
+        if (params.gPAIRED == 'paired'){
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
         } else{
             salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
         }
     }
     prepare_dtu_annotation()
-    if (RUNTERMINUS?.length() > 0){
+    if (params.gRUNTERMINUS?.length() > 0){
         terminus_collapse(salmon_quant.out.counts.collect())
         dtucounts = terminus_collapse.out.counts
     }
@@ -291,6 +295,6 @@ workflow DTU{
 
 
 workflow {
-    DTU(dummy)
+    DTU(dummy())
 }
 
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index f74d4542..7c21b10f 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -1,51 +1,75 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = { def MAPBIN = get_always('MAPPINGBIN'); MAPBIN = MAPBIN.replace('_', ' '); return MAPBIN }()
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
+params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +78,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +106,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +117,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +133,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +144,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +160,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +172,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,21 +189,21 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN $TRIMPARAMS t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
         """
     }
     else{
         o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"        
         r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN $TRIMPARAMS t=${task.cpus} in=$r1 out=$o &> $r 
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in=$r1 out=$o &> $r 
         """
     }
 }
@@ -190,13 +211,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -205,21 +226,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -237,7 +254,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -255,20 +272,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
-MAPPARAMS = get_always('bwa_params_MAP') ?: ''
-IDXBIN = MAPBIN.split('_')[0]
-MAPBIN = MAPBIN.replace('_', ' ')
 process collect_tomap{
     input:
     path check
@@ -280,16 +283,16 @@ process collect_tomap{
     """
 }
 process bwa_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename == "bwa.idx")                          "$MAPIDX"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
-        else                                                "$MAPUIDX"
+        if (filename == "bwa.idx")                          "${params.gMAPIDX}"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else                                                "${params.gMAPUIDX}"
     }
     input:
     path genome
@@ -299,19 +302,19 @@ process bwa_idx{
     script:
     gen =  genome.getName()
     """
-    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    mkdir -p ${params.gMAPUIDXNAME} && ${params.gIDXBIN} index -p ${params.gMAPUIDXNAME}/${params.gMAPPREFIX} ${params.gIDXPARAMS} $gen &> Log.out && ln -fs ${params.gMAPUIDXNAME} bwa.idx
     """
 }
 process bwa_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
-        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
         else null
     }
     input:
@@ -322,7 +325,7 @@ process bwa_mapping{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
@@ -331,7 +334,7 @@ process bwa_mapping{
         uf2 = fn+"_R2_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
         """
     }else{
         read = reads[1]
@@ -340,21 +343,21 @@ process bwa_mapping{
         uf = fn+"_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
         """
     }
 }
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     collection.filter(~/.fastq.gz/)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         bwa_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
+        genomefile = Channel.fromPath(params.gMAPREF)
         bwa_idx(genomefile)
         bwa_mapping(bwa_idx.out.bwidx.combine(collection))
     }
@@ -367,12 +370,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -390,14 +393,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -416,13 +419,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -433,26 +436,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -483,19 +486,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -509,8 +509,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -542,8 +542,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 6f38d6fa..2f58f05e 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -1,51 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +77,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +105,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +116,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +132,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +143,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +159,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +171,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,21 +188,21 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN $TRIMPARAMS t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
         """
     }
     else{
         o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"        
         r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN $TRIMPARAMS t=${task.cpus} in=$r1 out=$o &> $r 
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in=$r1 out=$o &> $r 
         """
     }
 }
@@ -190,13 +210,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -205,21 +225,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -237,7 +253,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -255,18 +271,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('star_params_INDEX') ?: ''
-MAPPARAMS = get_always('star_params_MAP') ?: ''
 process collect_tomap{
     input:
     path check
@@ -278,44 +282,44 @@ process collect_tomap{
     """
 }
 process star_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
-        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
-        else                                             "$MAPUIDX"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
     }
     input:
     path genome
     path anno
     output:
-    path "$MAPUIDXNAME", emit: idx
+    path "${params.gMAPUIDXNAME}", emit: idx
     path "*.out", emit: idxlog
     path "*.idx", emit: tmpidx
     script:
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
-        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
     input:
     path reads
@@ -329,7 +333,7 @@ process star_mapping{
     script:
     idx = reads[0]
     idxdir = idx.toRealPath()
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         a = "Trimming_report.txt"
@@ -337,31 +341,31 @@ process star_mapping{
         of = fn+'.Aligned.out.sam'
         gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
         """
-        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
         """
     }
     else{
-        if (PAIRED != 'singlecell'){
+        if (params.gPAIRED != 'singlecell'){
             read = reads[1]
             fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
             of = fn+'Aligned.out.sam'
             gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
             """
         }
         else{
-            if (STRANDED == 'fr'){
+            if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
-            }else if (STRANDED == 'rf'){
+            }else if (params.gSTRANDED == 'rf'){
                 stranded = '--soloStrand Reverse'
             }else{
                 stranded = '--soloStrand Unstranded'
             }
             r1 = reads[1]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
-            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
                 r1 = t
@@ -369,7 +373,7 @@ process star_mapping{
             of = fn+'.Aligned.sortedByCoord.out.bam'
             gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
             """
         }
     }
@@ -377,14 +381,14 @@ process star_mapping{
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         star_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
-        annofile = Channel.fromPath(MAPANNO)
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
         star_idx(genomefile, annofile)
         star_mapping(star_idx.out.idx.combine(collection))
     }
@@ -397,12 +401,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -420,14 +424,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -446,13 +450,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -463,26 +467,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -513,19 +517,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -539,8 +540,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -572,8 +573,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index b4b87dfe..9d8bbbfb 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -1,51 +1,75 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = { def MAPBIN = get_always('MAPPINGBIN'); MAPBIN = MAPBIN.replace('_', ' '); return MAPBIN }()
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
+params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +78,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +106,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +117,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +133,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +144,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +160,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +172,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,21 +189,21 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o -p $p $r1 $r2 &> $r
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o -p $p $r1 $r2 &> $r
         """
     }
     else{
         o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o $reads &> $r
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o $reads &> $r
         """
     }
 }
@@ -190,13 +211,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -205,21 +226,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -237,7 +254,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -255,20 +272,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
-MAPPARAMS = get_always('bwa_params_MAP') ?: ''
-IDXBIN = MAPBIN.split('_')[0]
-MAPBIN = MAPBIN.replace('_', ' ')
 process collect_tomap{
     input:
     path check
@@ -280,16 +283,16 @@ process collect_tomap{
     """
 }
 process bwa_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename == "bwa.idx")                          "$MAPIDX"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
-        else                                                "$MAPUIDX"
+        if (filename == "bwa.idx")                          "${params.gMAPIDX}"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else                                                "${params.gMAPUIDX}"
     }
     input:
     path genome
@@ -299,19 +302,19 @@ process bwa_idx{
     script:
     gen =  genome.getName()
     """
-    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    mkdir -p ${params.gMAPUIDXNAME} && ${params.gIDXBIN} index -p ${params.gMAPUIDXNAME}/${params.gMAPPREFIX} ${params.gIDXPARAMS} $gen &> Log.out && ln -fs ${params.gMAPUIDXNAME} bwa.idx
     """
 }
 process bwa_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
-        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
         else null
     }
     input:
@@ -322,7 +325,7 @@ process bwa_mapping{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
@@ -331,7 +334,7 @@ process bwa_mapping{
         uf2 = fn+"_R2_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
         """
     }else{
         read = reads[1]
@@ -340,21 +343,21 @@ process bwa_mapping{
         uf = fn+"_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
         """
     }
 }
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     collection.filter(~/.fastq.gz/)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         bwa_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
+        genomefile = Channel.fromPath(params.gMAPREF)
         bwa_idx(genomefile)
         bwa_mapping(bwa_idx.out.bwidx.combine(collection))
     }
@@ -367,12 +370,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -390,14 +393,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -416,13 +419,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -433,26 +436,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -483,19 +486,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -509,8 +509,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -542,8 +542,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index 5f91ce8f..725a5549 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -1,51 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +77,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +105,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +116,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +132,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +143,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +159,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +171,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,21 +188,21 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o -p $p $r1 $r2 &> $r
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o -p $p $r1 $r2 &> $r
         """
     }
     else{
         o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
         """
-        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o $reads &> $r
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o $reads &> $r
         """
     }
 }
@@ -190,13 +210,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -205,21 +225,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -237,7 +253,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -255,18 +271,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('star_params_INDEX') ?: ''
-MAPPARAMS = get_always('star_params_MAP') ?: ''
 process collect_tomap{
     input:
     path check
@@ -278,44 +282,44 @@ process collect_tomap{
     """
 }
 process star_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
-        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
-        else                                             "$MAPUIDX"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
     }
     input:
     path genome
     path anno
     output:
-    path "$MAPUIDXNAME", emit: idx
+    path "${params.gMAPUIDXNAME}", emit: idx
     path "*.out", emit: idxlog
     path "*.idx", emit: tmpidx
     script:
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
-        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
     input:
     path reads
@@ -329,7 +333,7 @@ process star_mapping{
     script:
     idx = reads[0]
     idxdir = idx.toRealPath()
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         a = "Trimming_report.txt"
@@ -337,31 +341,31 @@ process star_mapping{
         of = fn+'.Aligned.out.sam'
         gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
         """
-        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
         """
     }
     else{
-        if (PAIRED != 'singlecell'){
+        if (params.gPAIRED != 'singlecell'){
             read = reads[1]
             fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
             of = fn+'Aligned.out.sam'
             gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
             """
         }
         else{
-            if (STRANDED == 'fr'){
+            if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
-            }else if (STRANDED == 'rf'){
+            }else if (params.gSTRANDED == 'rf'){
                 stranded = '--soloStrand Reverse'
             }else{
                 stranded = '--soloStrand Unstranded'
             }
             r1 = reads[1]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
-            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
                 r1 = t
@@ -369,7 +373,7 @@ process star_mapping{
             of = fn+'.Aligned.sortedByCoord.out.bam'
             gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
             """
         }
     }
@@ -377,14 +381,14 @@ process star_mapping{
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         star_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
-        annofile = Channel.fromPath(MAPANNO)
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
         star_idx(genomefile, annofile)
         star_mapping(star_idx.out.idx.combine(collection))
     }
@@ -397,12 +401,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -420,14 +424,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -446,13 +450,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -463,26 +467,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -513,19 +517,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -539,8 +540,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -572,8 +573,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index 8188d76a..e3ce88c7 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -1,51 +1,75 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = { def MAPBIN = get_always('MAPPINGBIN'); MAPBIN = MAPBIN.replace('_', ' '); return MAPBIN }()
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
+params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +78,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +106,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +117,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +133,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +144,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +160,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +172,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,16 +189,16 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         """
-        $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
     }
     else{
         """
-        $TRIMBIN --cores ${task.cpus} --gzip $TRIMPARAMS $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        ${params.gTRIMBIN} --cores ${task.cpus} --gzip ${params.gTRIMPARAMS} $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
     }
 }
@@ -185,13 +206,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -200,21 +221,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -232,7 +249,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -250,20 +267,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('bwa_params_INDEX') ?: ''
-MAPPARAMS = get_always('bwa_params_MAP') ?: ''
-IDXBIN = MAPBIN.split('_')[0]
-MAPBIN = MAPBIN.replace('_', ' ')
 process collect_tomap{
     input:
     path check
@@ -275,16 +278,16 @@ process collect_tomap{
     """
 }
 process bwa_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename == "bwa.idx")                          "$MAPIDX"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
-        else                                                "$MAPUIDX"
+        if (filename == "bwa.idx")                          "${params.gMAPIDX}"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else                                                "${params.gMAPUIDX}"
     }
     input:
     path genome
@@ -294,19 +297,19 @@ process bwa_idx{
     script:
     gen =  genome.getName()
     """
-    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    mkdir -p ${params.gMAPUIDXNAME} && ${params.gIDXBIN} index -p ${params.gMAPUIDXNAME}/${params.gMAPPREFIX} ${params.gIDXPARAMS} $gen &> Log.out && ln -fs ${params.gMAPUIDXNAME} bwa.idx
     """
 }
 process bwa_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
-        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
         else null
     }
     input:
@@ -317,7 +320,7 @@ process bwa_mapping{
     path "*.log", emit: logs
     script:
     idx = reads[0]
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
@@ -326,7 +329,7 @@ process bwa_mapping{
         uf2 = fn+"_R2_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
         """
     }else{
         read = reads[1]
@@ -335,21 +338,21 @@ process bwa_mapping{
         uf = fn+"_unmapped.fastq.gz"
         lf = "bwa_"+fn+".log"
         """
-        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        ${params.gMAPBIN} ${params.gMAPPARAMS} -t ${task.cpus} ${idx}/${params.gMAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
         """
     }
 }
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     collection.filter(~/.fastq.gz/)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         bwa_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
+        genomefile = Channel.fromPath(params.gMAPREF)
         bwa_idx(genomefile)
         bwa_mapping(bwa_idx.out.bwidx.combine(collection))
     }
@@ -362,12 +365,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -385,14 +388,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -411,13 +414,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -428,26 +431,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -478,19 +481,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -504,8 +504,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -537,8 +537,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index 4cfad930..dc3f14f1 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -1,51 +1,74 @@
 #!/usr/bin/env nextflow
 nextflow.enable.dsl=2
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
 }
-REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
-REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
-BINS = get_always('BINS')
-THREADS = get_always('MAXTHREAD')
-PAIRED = get_always('PAIRED') ?: null
-RUNDEDUP = get_always('RUNDEDUP') ?: null
-PREDEDUP = get_always('PREDEDUP') ?: null
-STRANDED = get_always('STRANDED') ?: null
-IP = get_always('IP') ?: null
-CONDITION = get_always('CONDITION') ?: null
-COMBO = get_always('COMBO') ?: ''
-SCOMBO = get_always('SCOMBO') ?: ''
-SAMPLES = get_always('SAMPLES').split(',') ?: null
-LONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
-SHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
-SETS = get_always('SETS') ?: null
-dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
-if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-    RSAMPLES = SAMPLES.collect{
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
     }
 }else{
-    RSAMPLES=SAMPLES.collect{
+    return params.gSAMPLES.collect{
         element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
     }
 }
-samples_ch = Channel.fromPath(RSAMPLES)
+}()
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_QC') ?: ''
 process qc_raw{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -54,26 +77,26 @@ process qc_raw{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_RAW{
     take:
     collection
     main:
-    qc_raw(samples_ch)
+    qc_raw(samples_ch())
     emit:
     qc = qc_raw.out.fastqc_results
 }
 process qc_trimmed{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -82,7 +105,7 @@ process qc_trimmed{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_TRIMMING{
@@ -93,14 +116,14 @@ workflow QC_TRIMMING{
     qc = qc_trimmed.out.fastqc_results
 }
 process qc_mapped{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -109,7 +132,7 @@ process qc_mapped{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
     """
 }
 workflow QC_MAPPING{
@@ -120,14 +143,14 @@ workflow QC_MAPPING{
     qc = qc_mapped.out.fastqc_results
 }
 process qc_dedup{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
         else null
     }
     input:
@@ -136,7 +159,7 @@ process qc_dedup{
     path "*.{zip,html}", emit: fastqc_results
     script:
     """
-    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
     """
 }
 workflow QC_DEDUP{
@@ -148,18 +171,15 @@ workflow QC_DEDUP{
 }
 
 
-TRIMENV=get_always('TRIMMINGENV')
-TRIMBIN=get_always('TRIMMINGBIN')
-TRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
 process trim{
-    conda "<REPO>/envs/$TRIMENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$TRIMENV"
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
-        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -168,16 +188,16 @@ process trim{
     path "*_trimmed.fastq.gz", emit: trim
     path "*trimming_report.txt", emit: rep
     script:
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[0]
         r2 = reads[1]
         """
-        $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
     }
     else{
         """
-        $TRIMBIN --cores ${task.cpus} --gzip $TRIMPARAMS $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        ${params.gTRIMBIN} --cores ${task.cpus} --gzip ${params.gTRIMPARAMS} $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
     }
 }
@@ -185,13 +205,13 @@ workflow TRIMMING{
     take: 
     collection    
     main:
-    if ( PREDEDUP == 'enabled' ){  
+    if ( params.gPREDEDUP == 'enabled' ){  
         trim(collection)
     }else {        
-        if (PAIRED == 'paired'){
-            trim(samples_ch.collate(2))
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
         } else{
-            trim(samples_ch.collate(1))
+            trim(samples_ch().collate(1))
         }
     }
     emit:
@@ -200,21 +220,17 @@ workflow TRIMMING{
 }
 
 
-DEDUPENV=get_always('DEDUPENV')
-DEDUPBIN=get_always('DEDUPBIN')
-DEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
-JAVAPARAMS = get_always('picard_params_JAVA') ?: ''
 process dedup_bam{
-    conda "<REPO>/envs/$DEDUPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$DEDUPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
-        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
     input:
@@ -232,7 +248,7 @@ process dedup_bam{
     outl = bams.getSimpleName()+"_dedup.log"
     outm = bams.getSimpleName()+"_dedup_metrix.txt"
     """
-    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
     """
 }
 workflow DEDUPBAM{
@@ -250,18 +266,6 @@ workflow DEDUPBAM{
 }
 
 
-MAPENV = get_always('MAPPINGENV')
-MAPBIN = get_always('MAPPINGBIN')
-MAPIDX = get_always('MAPPINGIDX')
-MAPUIDX = get_always('MAPPINGUIDX')
-MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
-MAPREF = get_always('MAPPINGREF')
-MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
-MAPANNO = get_always('MAPPINGANNO')
-MAPPREFIX = get_always('MAPPINGPREFIX')
-MAPUIDX = MAPUIDX.replace('.idx','')
-IDXPARAMS = get_always('star_params_INDEX') ?: ''
-MAPPARAMS = get_always('star_params_MAP') ?: ''
 process collect_tomap{
     input:
     path check
@@ -273,44 +277,44 @@ process collect_tomap{
     """
 }
 process star_idx{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
-        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
-        else                                             "$MAPUIDX"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
     }
     input:
     path genome
     path anno
     output:
-    path "$MAPUIDXNAME", emit: idx
+    path "${params.gMAPUIDXNAME}", emit: idx
     path "*.out", emit: idxlog
     path "*.idx", emit: tmpidx
     script:
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
-    conda "<REPO>/envs/$MAPENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$MAPENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
-        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
     input:
     path reads
@@ -324,7 +328,7 @@ process star_mapping{
     script:
     idx = reads[0]
     idxdir = idx.toRealPath()
-    if (PAIRED == 'paired'){
+    if (params.gPAIRED == 'paired'){
         r1 = reads[1]
         r2 = reads[2]
         a = "Trimming_report.txt"
@@ -332,31 +336,31 @@ process star_mapping{
         of = fn+'.Aligned.out.sam'
         gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
         """
-        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
         """
     }
     else{
-        if (PAIRED != 'singlecell'){
+        if (params.gPAIRED != 'singlecell'){
             read = reads[1]
             fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
             of = fn+'Aligned.out.sam'
             gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
             """
         }
         else{
-            if (STRANDED == 'fr'){
+            if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
-            }else if (STRANDED == 'rf'){
+            }else if (params.gSTRANDED == 'rf'){
                 stranded = '--soloStrand Reverse'
             }else{
                 stranded = '--soloStrand Unstranded'
             }
             r1 = reads[1]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
-            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
                 r1 = t
@@ -364,7 +368,7 @@ process star_mapping{
             of = fn+'.Aligned.sortedByCoord.out.bam'
             gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
             """
-            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
             """
         }
     }
@@ -372,14 +376,14 @@ process star_mapping{
 workflow MAPPING{
     take: collection
     main:
-    checkidx = file(MAPUIDX)
+    checkidx = file(params.gMAPUIDX)
     if (checkidx.exists()){
-        idxfile = Channel.fromPath(MAPUIDX)
+        idxfile = Channel.fromPath(params.gMAPUIDX)
         star_mapping(idxfile.combine(collection))
     }
     else{
-        genomefile = Channel.fromPath(MAPREF)
-        annofile = Channel.fromPath(MAPANNO)
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
         star_idx(genomefile, annofile)
         star_mapping(star_idx.out.idx.combine(collection))
     }
@@ -392,12 +396,12 @@ workflow MAPPING{
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
         else null
     }
     input:
@@ -415,14 +419,14 @@ process sortsam{
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -441,13 +445,13 @@ process sam2bam{
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -458,26 +462,26 @@ process uniqsam{
     script:
     fn = file(sam[0]).getSimpleName()
     uniq = fn+'_unique.sam.gz'
-    if (COMBO.indexOf('-bwa') > 0){
+    if (params.gCOMBO.indexOf('-bwa') > 0){
         bwa = 'bwa'
     } else{
         bwa = ''
     }
     """
-    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
     """
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
     container "oras://docker.io/jfallmann/monsda:"+"samtools"
-    cpus THREADS
+    cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
-        else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -508,19 +512,16 @@ workflow POSTMAPPING{
 }
 
 
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 process mqc{
-    conda "<REPO>/envs/$QCENV"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"$QCENV"
-    cpus THREADS
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("zip") > 0)          "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
-        else if (filename.indexOf("html") > 0)    "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
-        else "QC/Multi/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path others, stageAs: 'mqc_input??/*'
@@ -534,8 +535,8 @@ process mqc{
     LIST=multiqc_inputs.txt
     TMP_LIST=multiqc_inputs_unique.txt
     BASE_QC_DIR="${workflow.workDir}/../QC"
-    COMBO_VAL="${COMBO}"
-    CONDITION_VAL="${CONDITION}"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
     for i in $others; do
         dirname "\$i" >> "\$LIST"
     done
@@ -567,8 +568,8 @@ workflow MULTIQC{
 
 
 workflow {
-    QC_RAW(dummy)
-    TRIMMING(dummy)
+    QC_RAW(dummy())
+    TRIMMING(dummy())
     QC_TRIMMING(TRIMMING.out.trimmed)
     MAPPING(TRIMMING.out.trimmed)
     POSTMAPPING(MAPPING.out.mapped)
diff --git a/workflows/countreads.nf b/workflows/countreads.nf
index 377410ba..735e02e7 100644
--- a/workflows/countreads.nf
+++ b/workflows/countreads.nf
@@ -12,6 +12,7 @@ COUNTUIDX?.replace('.idx','')
 COUNTPARAMS = get_always('featurecounts_params_COUNT') ?: ''
 FEAT = get_always('COUNTINGFEAT') ?: ''
 COUNTMAP = get_always('COUNTINGMAP') ?: ''
+DEREPS = get_always('DEREPS') ?: ''
 
 //COUNTING PROCESSES
 process count_fastq{
@@ -226,8 +227,8 @@ process featurecount{
 
 
 process prepare_count_table{
-    conda "$DEENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$DEENV"
+    conda "base.yaml"
+    container "oras://jfallmann/monsda:"+"base"
     cpus THREADS
 	cache 'lenient'
     //validExitStatus 0,1
diff --git a/workflows/header.nf b/workflows/header.nf
index 7aaa6158..77d1a2b5 100644
--- a/workflows/header.nf
+++ b/workflows/header.nf
@@ -12,10 +12,7 @@ nextflow.enable.dsl=2
 
 //define unset Params
 def get_always(parameter){
-    if (!params.containsKey(parameter)){
-        params.put(parameter, null)
-    }
-    return params[parameter]
+    return params.containsKey(parameter) ? params[parameter] : null
 }
 
 //Params from CL
diff --git a/workflows/kallisto.nf b/workflows/kallisto.nf
index 2b3ecef1..1e032b57 100644
--- a/workflows/kallisto.nf
+++ b/workflows/kallisto.nf
@@ -6,7 +6,7 @@ COUNTUIDXNAME = get_always('COUNTINGUIDXNAME')+'.idx'
 COUNTREF = get_always('COUNTINGREF')
 COUNTREFDIR = "${workflow.workDir}/../"+get_always('COUNTINGREFDIR')
 COUNTANNO = get_always('COUNTINGANNO')
-COUNTDECOY = get_always('COUNTINDECOY')
+COUNTDECOY = get_always('COUNTINGDECOY')
 COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
 
 IDXPARAMS = get_always('kallisto_params_INDEX') ?: ''
@@ -76,8 +76,8 @@ process kallisto_idx{
 
     script:    
     gen =  genome.getName()
-    if (${COUNTINGDECOY}){
-        decoy = "-d "+"${COUNTINGDECOY}" 
+    if (COUNTDECOY && COUNTDECOY != 'None'){
+        decoy = "-d "+"${COUNTDECOY}" 
     }else{
         decoy = ''
     }
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index fc7eb919..c75b3dd0 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -7,7 +7,7 @@ COUNTUIDXNAME = get_always('COUNTINGUIDXNAME')
 COUNTREF = get_always('COUNTINGREF')
 COUNTREFDIR = "${workflow.workDir}/../"+get_always('COUNTINGREFDIR')
 COUNTANNO = get_always('COUNTINGANNO')
-COUNTDECOY = get_always('COUNTINDECOY')
+COUNTDECOY = get_always('COUNTINGDECOY')
 COUNTPREFIX = get_always('COUNTINGPREFIX') ?: COUNTBIN.split(' ')[0]
 
 IDXPARAMS = get_always('salmon_params_INDEX') ?: ''
@@ -78,8 +78,8 @@ process salmon_idx{
 
     script:    
     gen =  genome.getName()
-    if (${COUNTINGDECOY}){
-        decoy = "-d "+"${COUNTINGDECOY}" 
+    if (COUNTDECOY && COUNTDECOY != 'None'){
+        decoy = "-d "+"${COUNTDECOY}" 
     }else{
         decoy = ''
     }

From 2c936985b9b99cca043a76fe551a4b54ec685d06 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Sun, 5 Jul 2026 21:03:01 +0200
Subject: [PATCH 09/80] fixed params error in DE runs

---
 MONSDA/Params.py                   | 4 ++--
 scripts/Analysis/DE/DESEQ2.R       | 2 +-
 scripts/Analysis/DE/EDGER.R        | 2 +-
 scripts/Analysis/DE/EDGER_no_rep.R | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/MONSDA/Params.py b/MONSDA/Params.py
index 80a71fbb..fb6767e1 100644
--- a/MONSDA/Params.py
+++ b/MONSDA/Params.py
@@ -1173,7 +1173,7 @@ def get_reps(samples: list, config: dict, analysis: str, process: str = "smk") -
         if (
             "BATCHES" in partconf
             and len(partconf["BATCHES"]) >= idx + 1
-            and partconf.get("BATCHES") != ""
+            and str(partconf["BATCHES"][idx]) != ""
         ):
             ret["batches"].append(str(partconf["BATCHES"][idx]).replace(",", "_"))
         else:
@@ -1181,7 +1181,7 @@ def get_reps(samples: list, config: dict, analysis: str, process: str = "smk") -
         if (
             "TYPES" in partconf
             and len(partconf["TYPES"]) >= idx + 1
-            and partconf.get("TYPE") != ""
+            and str(partconf["TYPES"][idx]) != ""
         ):
             ret["types"].append(str(partconf["TYPES"][idx]).replace(",", "_"))
         else:
diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index aa3e59db..f934176f 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -39,7 +39,7 @@ BPPARAM <- MulticoreParam(workers = availablecores)
 
 ### SCRIPT
 ## Annotation
-sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE))
+sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE, sep = "\t"))
 colnames(sampleData_all) <- c("condition", "type", "batch")
 sampleData_all$batch <- as.factor(sampleData_all$batch)
 sampleData_all$type <- as.factor(sampleData_all$type)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index d32cc218..933fc16b 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -41,7 +41,7 @@ gtf.df <- as.data.frame(gtf.rtl)
 gtf_gene <- droplevels(subset(gtf.df, type == "gene"))
 
 ## Annotation
-sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE))
+sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE, sep = "\t"))
 colnames(sampleData_all) <- c("condition", "type", "batch")
 sampleData_all$condition <- as.factor(sampleData_all$condition)
 sampleData_all$batch <- as.factor(sampleData_all$batch)
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index ea27bbd9..dd02894e 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -46,7 +46,7 @@ gtf.df <- as.data.frame(gtf.rtl)
 gtf_gene <- droplevels(subset(gtf.df, type == "gene"))
 
 ## Annotation
-sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE))
+sampleData_all <- as.data.frame(read.table(gzfile(anname), row.names = 1, check.names = FALSE, sep = "\t"))
 colnames(sampleData_all) <- c("condition", "type", "batch")
 sampleData_all$condition <- as.factor(sampleData_all$condition)
 sampleData_all$batch <- as.factor(sampleData_all$batch)

From a1d0e44a42d21e157f8f7508025e25ed800a87ca Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Sun, 5 Jul 2026 21:08:24 +0200
Subject: [PATCH 10/80] disbled legacy parser

---
 MONSDA/RunMONSDA.py | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index fc287583..bbbf838d 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -2,7 +2,6 @@
 
 import argparse
 import os
-import re
 import shlex
 import shutil
 import subprocess
@@ -857,19 +856,9 @@ def run_nextflow(
 def runjob(jobtorun):
     try:
         logid = scriptname + ".runjob: "
-        run_cmd = jobtorun
-        if (
-            re.search(r"(^|\s)nextflow(\s|$)", jobtorun)
-            and "NXF_SYNTAX_PARSER" not in jobtorun
-        ):
-            run_cmd = "NXF_SYNTAX_PARSER=v1 " + jobtorun
-            log.warning(
-                logid
-                + "Nextflow 26.04+ strict parser detected; forcing legacy parser (NXF_SYNTAX_PARSER=v1) for compatibility with generated workflows."
-            )
         # return subprocess.run(jobtorun, shell=True, universal_newlines=True, capture_output=True)  # python >= 3.7
         job = subprocess.Popen(
-            run_cmd,
+            jobtorun,
             shell=True,
             universal_newlines=True,
             stdout=subprocess.PIPE,

From da04552199b95822e1ffd63606cfc8fc2a5683dc Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 6 Jul 2026 22:58:19 +0200
Subject: [PATCH 11/80] Added Star-fusion in star or fastq mode, fable built
 tests and workflows based on CIRI2 template

---
 .vscode/settings.json                         |   3 +-
 MONSDA/Workflows.py                           |  39 +-
 configs/template.json                         |  24 +-
 configs/template_base_commented.json          |   2 +-
 configs/template_clean.json                   |  22 +
 containers/apptainer/starfusion.def           |  23 ++
 docs/source/workflows.rst                     |  31 ++
 envs/starfusion.yaml                          |   7 +
 profile_snakemake/cluster_config.yaml         |   8 +
 tests/data/config_DTU_test.json               |  16 +-
 tests/golden/config_FUSIONS/nf/_filelist.txt  |   2 +
 ...ard-star_FUSIONS_starfusion_subconfig.json |  49 +++
 ...-picard-star_FUSIONS_starfusion_subflow.nf |  97 +++++
 tests/golden/config_FUSIONS/smk/_filelist.txt |   2 +
 ...ard-star_FUSIONS_starfusion_subconfig.json |  49 +++
 ...icard-star_FUSIONS_starfusion_subsnake.smk | 387 ++++++++++++++++++
 tests/test_Workflows.py                       |  53 +++
 workflows/starfusion.nf                       |  64 +++
 workflows/starfusion.smk                      |  71 ++++
 19 files changed, 944 insertions(+), 5 deletions(-)
 create mode 100644 containers/apptainer/starfusion.def
 create mode 100644 envs/starfusion.yaml
 create mode 100644 tests/golden/config_FUSIONS/nf/_filelist.txt
 create mode 100644 tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
 create mode 100644 tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
 create mode 100644 tests/golden/config_FUSIONS/smk/_filelist.txt
 create mode 100644 tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
 create mode 100644 tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
 create mode 100644 workflows/starfusion.nf
 create mode 100644 workflows/starfusion.smk

diff --git a/.vscode/settings.json b/.vscode/settings.json
index b3c483e6..b04e345e 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -28,5 +28,6 @@
     "[python]": {
         "editor.defaultFormatter": "ms-python.black-formatter"
     },
-    "python.formatting.provider": "none"
+    "python.formatting.provider": "none",
+    "makefile.configureOnOpen": false
 }
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 82125342..424d1549 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -431,7 +431,7 @@ def get_processes(config):
     # Define workflow stages
     pre = ["QC", "FETCH", "BASECALL"]
     sub = ["TRIMMING", "MAPPING", "DEDUP", "QC"]
-    post = ["COUNTING", "TRACKS", "PEAKS", "DE", "DEU", "DAS", "DTU", "CIRCS"]
+    post = ["COUNTING", "TRACKS", "PEAKS", "DE", "DEU", "DAS", "DTU", "CIRCS", "FUSIONS"]
 
     wfs = [x.replace(" ", "") for x in config["WORKFLOWS"].split(",")]
 
@@ -643,6 +643,7 @@ def create_subworkflow(config, subwork, conditions, envs=None, stage=None):
                                 "COUNTING",
                                 "TRACKS",
                                 "CIRCS",
+                                "FUSIONS",
                             ]
                         ]
                     ):
@@ -1373,6 +1374,12 @@ def make_post(
                             "CIRI2 needs BWA mapped files, will skip input produced otherwise"
                         )
                         continue
+                if postworkflow == "FUSIONS":
+                    if toolenv == "starfusion" and "star" not in envs:
+                        log.warning(
+                            "STAR-Fusion needs STAR chimeric output, will skip input produced otherwise"
+                        )
+                        continue
 
                 # Deep-merge postworkflow config from all conditions (preserves all condition paths)
                 for cond in all_conditions:
@@ -2231,6 +2238,30 @@ def nf_fetch_params(
         retconf["CIRCSREFDIR"] = REFDIR
         retconf["CIRCSANNO"] = ANNOTATION
 
+    # FUSIONS Variables
+    if "FUSIONS" in config:
+        FUSCONF = mu.sub_dict(config["FUSIONS"], SETUP)
+        FUSBIN, FUSENV = mp.env_bin_from_config(config, "FUSIONS")
+        log.debug(logid + "FUSIONSCONFIG: " + str(SETUP) + "\t" + str(FUSCONF))
+        REF = FUSCONF.get("REFERENCE")
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        FANNO = FUSCONF.get("ANNOTATION")
+        if FANNO:
+            ANNOTATION = FANNO
+        else:
+            ANNOTATION = (
+                ANNO.get("GTF") if "GTF" in ANNO else ANNO.get("GFF")
+            )  # by default GTF format will be used
+
+        retconf["FUSIONSREF"] = REFERENCE
+        retconf["FUSIONSREFDIR"] = REFDIR
+        retconf["FUSIONSANNO"] = ANNOTATION
+        retconf["FUSIONSLIB"] = (
+            FUSCONF.get(FUSENV, {}).get("OPTIONS", {}).get("INDEX", "")
+        )
+
     retconf["REFERENCE"] = REFERENCE
     retconf["REFDIR"] = REFDIR
     retconf["IP"] = IP
@@ -3477,6 +3508,12 @@ def nf_make_post(
                             "CIRI2 needs BWA mapped files, will skip input produced otherwise"
                         )
                         continue
+                if subwork == "FUSIONS":
+                    if toolenv == "starfusion" and "star" not in envs:
+                        log.warning(
+                            "STAR-Fusion needs STAR chimeric output, will skip input produced otherwise"
+                        )
+                        continue
 
                 # Merge subwork config from all conditions
                 for cond in all_conditions:
diff --git a/configs/template.json b/configs/template.json
index 5ec96ff3..a23f4e4d 100644
--- a/configs/template.json
+++ b/configs/template.json
@@ -1,5 +1,5 @@
 {
-    "WORKFLOWS": "", #which workflows do you want to run "MAPPING, QC, DEDUP, TRIMMING, COUNTING, TRACKS, PEAKS, DE, DEU, DAS, DTU, CIRCS"
+    "WORKFLOWS": "", #which workflows do you want to run "MAPPING, QC, DEDUP, TRIMMING, COUNTING, TRACKS, PEAKS, DE, DEU, DAS, DTU, CIRCS, FUSIONS"
     "BINS": "", #where to find customscripts used in the workflow !!!ADVANCED USAGE ONLY!!!
     "MAXTHREADS": "20", #maximum number of cores to use, make sure this fits your needs
     "VERSION": "1.4.0", #needs to be identical to the installed version for reproducibility reasons
@@ -509,5 +509,27 @@
                 }
             }
         }
+    },
+    "FUSIONS" : {
+        "TOOLS" :
+        {
+            "starfusion" : "STAR-Fusion"
+        },
+        "id": {
+            "condition": {
+                "setting": {
+                    "ENV" : "starfusion",
+                    "BIN" : "STAR-Fusion",
+                    "starfusion":{
+                        "OPTIONS":
+                        {
+                            "INDEX": "PATH_TO_CTAT_genome_lib_dir",  # Path to an existing CTAT genome resource library, will be built from REFERENCE/ANNOTATION if not present
+                            "BUILD": "",  # Additional options for prep_genome_lib.pl when building the CTAT library
+                            "FUSION": ""  # Additional options for STAR-Fusion; set "FASTQ": "true" to run in FASTQ mode instead of consuming STAR chimeric junctions
+                        }
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index b3e820ad..4fb0cfec 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -1,6 +1,6 @@
 {
   "comment":{
-    "WORKFLOWS": "Select workflows you want to run, possible values: FETCH, MAPPING, QC, DEDUP, TRIMMING, COUNTING, TRACKS, PEAKS, DE, DEU, DAS, DTU, CIRCS",
+    "WORKFLOWS": "Select workflows you want to run, possible values: FETCH, MAPPING, QC, DEDUP, TRIMMING, COUNTING, TRACKS, PEAKS, DE, DEU, DAS, DTU, CIRCS, FUSIONS",
     "BINS": "Where to find the scripts used in the workflow, per default the scripts directory that comes with MONSDA. ONLY CHANGE IF YOU KNOW WHAT YOU ARE DOING!",
     "MAXTHREADS": "Maximum number of cores to use, make sure this fits your needs, acts as upper cap.",
     "VERSION": "Version of MONSDA to use, needs to match installed version"
diff --git a/configs/template_clean.json b/configs/template_clean.json
index 94e94949..903d7abe 100644
--- a/configs/template_clean.json
+++ b/configs/template_clean.json
@@ -482,4 +482,26 @@
             }
         }
     }
+  },
+  "FUSIONS" : {
+    "TOOLS" :
+    {
+      "starfusion" : "STAR-Fusion"
+    },
+    "id": {
+        "condition": {
+            "setting": {
+                "ENV" : "starfusion",
+                "BIN" : "STAR-Fusion",
+                "starfusion":{
+                    "OPTIONS":
+                    {  
+                        "INDEX": "PATH_TO_CTAT_genome_lib_dir",
+                        "BUILD": "",
+                        "FUSION": ""
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/containers/apptainer/starfusion.def b/containers/apptainer/starfusion.def
new file mode 100644
index 00000000..64818735
--- /dev/null
+++ b/containers/apptainer/starfusion.def
@@ -0,0 +1,23 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+   
+%files
+    /home/fall/MONSDA/envs/starfusion.yaml /opt/envs/
+    ${HOME}/MONSDA/scripts /opt/MONSDA/
+
+%environment
+   
+%post
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/starfusion.yaml
+    
+    ENV_NAME=starfusion
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+   
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/starfusion.yaml -p /opt/conda/envs/$ENV_NAME
+    conda clean --all
+   
+%runscript
+    exec "$@"
\ No newline at end of file
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index 61b75be0..07f1fb85 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -32,6 +32,8 @@ DTU -> Differential Transcript Usage Analysis
 
 CIRCS -> Circular RNA identification
 
+FUSIONS -> Fusion gene detection
+
 
 PREPROCESSING
 =============
@@ -304,3 +306,32 @@ Find circular RNAs in mapping data, CIRI2 needs to be installed locally.
   +=======+=========================================================================================================================================================================================================+========+====================+=======================================================================+========+==================+
   | CIRI2 | CIRI (circRNA identifier) is a novel chiastic clipping signal based algorithm,which can unbiasedly and accurately detect circRNAs from transcriptome data by employing multiple filtration strategies.  | ciri2  | $Path_to_CIRI2.pl  | `ciri2 <https://ciri-cookbook.readthedocs.io/en/latest/CIRI2.html>`_  | BAM    | BED/BEDG/BIGWIG  |
   +-------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+--------------------+-----------------------------------------------------------------------+--------+------------------+
+
+
+FUSIONS
+###############
+
+Detect fusion genes with STAR-Fusion. FUSIONS requires STAR in the MAPPING step and, by
+default, consumes the chimeric junctions produced by STAR. STAR does not emit chimeric output
+unless configured to do so, therefore add the chimeric options to the STAR ``MAP`` options in
+the MAPPING config, e.g. ``--chimSegmentMin 12 --chimOutType Junctions``. MONSDA then finds the
+resulting ``MAPPED/<combo>/<sample>.Chimeric.out.junction`` files and only runs STAR-Fusion when
+they exist. Set ``"FASTQ": "true"`` in the FUSIONS ``OPTIONS`` to run STAR-Fusion directly on the
+trimmed FASTQ files instead of the chimeric junctions.
+
+STAR-Fusion needs a CTAT genome resource library. Point ``INDEX`` to an existing
+``genome_lib_dir``; if it does not exist, it is built from ``REFERENCE`` and ``ANNOTATION`` with
+``prep_genome_lib.pl`` (extra build options can be passed via ``BUILD``). Building a CTAT library
+is resource intensive, so the bundled cluster profile sets a long runtime for the
+``generate_ctat_lib`` rule.
+
+.. table:: 
+  :widths: 10, 40, 10, 10, 10, 10, 10
+  :class: tight-table
+
+  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+----------------------------------------------------------------+-------------------------------+---------+
+  | TOOL        | DESCRIPTION                                                                                                                                                                             | ENV        | BIN         | LINK                                                           | INPUT                         | OUTPUT  |
+  +=============+=========================================================================================================================================================================================+============+=============+================================================================+===============================+=========+
+  | STAR-Fusion | STAR-Fusion identifies candidate fusion transcripts from the chimeric alignments produced by the STAR aligner using a CTAT genome resource library.                                      | starfusion | STAR-Fusion | `starfusion <https://github.com/STAR-Fusion/STAR-Fusion/wiki>`_ | Chimeric.out.junction / FASTQ | TSV     |
+  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+----------------------------------------------------------------+-------------------------------+---------+
+
diff --git a/envs/starfusion.yaml b/envs/starfusion.yaml
new file mode 100644
index 00000000..4f431f93
--- /dev/null
+++ b/envs/starfusion.yaml
@@ -0,0 +1,7 @@
+name: starfusion
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - star-fusion =1.15.1
diff --git a/profile_snakemake/cluster_config.yaml b/profile_snakemake/cluster_config.yaml
index f9f7b122..f2f619f8 100644
--- a/profile_snakemake/cluster_config.yaml
+++ b/profile_snakemake/cluster_config.yaml
@@ -14,5 +14,13 @@ generate_index:
 mapping:
     mem: 200GB
 
+generate_ctat_lib:
+    mem: 200GB
+    time: 2880
+
+starfusion:
+    mem: 100GB
+    time: 1500
+
 multiqc:
    mem: 30GB
diff --git a/tests/data/config_DTU_test.json b/tests/data/config_DTU_test.json
index 6852e250..c990a099 100644
--- a/tests/data/config_DTU_test.json
+++ b/tests/data/config_DTU_test.json
@@ -1,5 +1,5 @@
 {
-    "WORKFLOWS": "QC,TRIMMING,DEDUP,MAPPING,DTU",
+    "WORKFLOWS": "QC,TRIMMING,DEDUP,MAPPING,DTU,FUSIONS",
     "BINS": "",
     "MAXTHREADS": "4",
     "VERSION": "FIXME",
@@ -124,5 +124,19 @@
                 }
             }
         }
+    },
+    "FUSIONS": {
+        "TOOLS": {
+            "starfusion": "STAR-Fusion"
+        },
+        "Test": {
+            "starfusion": {
+                "OPTIONS": {
+                    "INDEX": "GENOMES/ctat_genome_lib",
+                    "BUILD": "",
+                    "FUSION": ""
+                }
+            }
+        }
     }
 }
diff --git a/tests/golden/config_FUSIONS/nf/_filelist.txt b/tests/golden/config_FUSIONS/nf/_filelist.txt
new file mode 100644
index 00000000..a1df64ea
--- /dev/null
+++ b/tests/golden/config_FUSIONS/nf/_filelist.txt
@@ -0,0 +1,2 @@
+allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
new file mode 100644
index 00000000..ba769040
--- /dev/null
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
@@ -0,0 +1,49 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "FUSIONS": {
+    "Test": {
+      "starfusion": {
+        "OPTIONS": {
+          "BUILD": "",
+          "FUSION": "",
+          "INDEX": "GENOMES/ctat_genome_lib"
+        }
+      }
+    }
+  },
+  "FUSIONSBIN": "STAR-Fusion",
+  "FUSIONSENV": "starfusion",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
new file mode 100644
index 00000000..acd2e5fe
--- /dev/null
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -0,0 +1,97 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
+}
+params.gFUSENV = get_always('FUSIONSENV')
+params.gFUSBIN = get_always('FUSIONSBIN')
+params.gFUSREF = get_always('FUSIONSREF')
+params.gFUSREFDIR = "${workflow.workDir}/../"+get_always('FUSIONSREFDIR')
+params.gFUSANNO = get_always('FUSIONSANNO')
+params.gFUSLIB = get_always('FUSIONSLIB')
+params.gFUSPARAMS = get_always('starfusion_params_FUSION') ?: ''
+params.gFUSBUILD = get_always('starfusion_params_BUILD') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+}()
+
+process starfusion{
+    conda "<REPO>/envs/${params.gFUSENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gFUSENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_fusions") > 0)      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"        
+        else if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
+    }
+    input:
+    path fls
+    output:
+    path "*_fusions", emit: fusions
+    path "log", emit: log
+    script:
+    ref = fls[0]
+    anno = fls[1]
+    junction = fls[2]        
+    fn = file(junction).getSimpleName()
+    of = fn+"_fusions"
+    ol = fn+".log"
+    """
+    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; else CTAT=CTAT; mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} &> log; fi; if [[ -s \"${junction}\" ]]; then ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    """
+}
+workflow FUSIONS{ 
+    take: collection
+    main:
+    MAPPEDSAMPLES = params.gLONGSAMPLES.collect{
+        element -> return "${workflow.workDir}/../MAPPED/${params.gCOMBO}/"+element+"*.Chimeric.out.junction"
+    }
+    mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())  
+    annofile = Channel.fromPath(params.gFUSANNO)
+    genomefile = Channel.fromPath(params.gFUSREF)
+    starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+    emit:
+    fusions = starfusion.out.fusions
+    logs = starfusion.out.log
+}
+
+
+
+
+workflow {
+    FUSIONS(dummy())
+}
+
diff --git a/tests/golden/config_FUSIONS/smk/_filelist.txt b/tests/golden/config_FUSIONS/smk/_filelist.txt
new file mode 100644
index 00000000..64f75e1f
--- /dev/null
+++ b/tests/golden/config_FUSIONS/smk/_filelist.txt
@@ -0,0 +1,2 @@
+allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
+allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
new file mode 100644
index 00000000..ba769040
--- /dev/null
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subconfig.json
@@ -0,0 +1,49 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "FUSIONS": {
+    "Test": {
+      "starfusion": {
+        "OPTIONS": {
+          "BUILD": "",
+          "FUSION": "",
+          "INDEX": "GENOMES/ctat_genome_lib"
+        }
+      }
+    }
+  },
+  "FUSIONSBIN": "STAR-Fusion",
+  "FUSIONSENV": "starfusion",
+  "MAXTHREADS": "4",
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "Test/SRR6357070",
+    "Test/SRR6357071",
+    "Test/SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
new file mode 100644
index 00000000..04411316
--- /dev/null
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -0,0 +1,387 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-star/starfusion'
+
+scombo = 'fastqc-trimgalore-picard-star'
+
+wildcard_constraints:
+    combo = combo,
+    scombo = scombo,
+    read = "R1|R2",
+    type = "sorted|sorted_unique" if not rundedup else "sorted|sorted_unique|sorted_dedup|sorted_unique_dedup"
+
+FBIN, FENV = env_bin_from_config(config, 'FUSIONS')
+if not 'star' in combo or not 'star' in scombo:
+        log.warning('STAR-Fusion needs STAR chimeric output, can only be used with STAR in mapping step')
+fusopts = tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS']
+fastqmode = str(fusopts.get('FASTQ', "")).lower() in ("1", "true", "yes")
+CTATLIB = fusopts.get('INDEX', "") or os.path.join(REFDIR, "CTAT", FENV)
+if not rundedup:
+    rule themall:
+        input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    rule themall:
+        input:  expand("FUSIONS/{combo}/{file}_{type}", combo=combo, file=samplecond(SAMPLES, config), type=['sorted', 'sorted_dedup'])
+rule generate_ctat_lib:
+    input:  fa = REFERENCE,
+            anno = ANNOTATION
+    output: lib = directory(CTATLIB),
+            tmpfa = temp(expand("TMP/{fenv}/ctat_ref.fa", fenv=FENV)),
+            tmpanno = temp(expand("TMP/{fenv}/ctat_ref.gtf", fenv=FENV))
+    log:    expand("LOGS/{sets}/{fenv}.ctat.log", sets=SETS, fenv=FENV)
+    conda:  "<REPO>/envs/"+FENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+    threads: MAXTHREAD
+    params: sf = FBIN,
+            bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
+    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && touch {output.tmpfa} {output.tmpanno}; else zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} &> {log}; fi"
+if not fastqmode:
+    rule starfusion:
+        input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
+                lib = rules.generate_ctat_lib.output.lib
+        output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+        log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+        conda:  "<REPO>/envs/"+FENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+        threads: MAXTHREAD
+        params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                sf = FBIN
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+else:
+    if paired == 'paired':
+        rule starfusion:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    lib = rules.generate_ctat_lib.output.lib
+            output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            conda:  "<REPO>/envs/"+FENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+            threads: MAXTHREAD
+            params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                    sf = FBIN
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+    else:
+        rule starfusion:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    lib = rules.generate_ctat_lib.output.lib
+            output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            conda:  "<REPO>/envs/"+FENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+            threads: MAXTHREAD
+            params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                    sf = FBIN
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str({log}))
+
+
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index 45f1e1b0..e3020b90 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -250,6 +250,59 @@ def test_make_post_dtu_file_set_stable(engine, workdir):
     _check_golden(f"config_DTU/{engine}/_filelist.txt", "\n".join(names) + "\n")
 
 
+# --------------------------------------------------------------------------- #
+# Golden-file snapshot for the FUSIONS postprocessing step (STAR-Fusion).
+# --------------------------------------------------------------------------- #
+
+
+def _generate_fusions(engine, workdir):
+    cfg = _load("config_DTU_test.json")
+    conditions = mp.get_conditions(cfg)
+    _pre, sub, _post = mw.get_processes(cfg)
+    combos = mw.get_combo(sub, cfg, conditions)
+    samples = mp.get_samples_postprocess(cfg, "FUSIONS")
+    if engine == "smk":
+        subdir = "SubFusionSnakes"
+        mp.create_skeleton(subdir, None)
+        mw.make_post(
+            "FUSIONS", cfg, samples, conditions, subdir, "INFO", combinations=combos
+        )
+    else:
+        subdir = "SubFusionFlows"
+        mp.create_skeleton(subdir, None)
+        mw.nf_make_post(
+            "FUSIONS", cfg, samples, conditions, subdir, "INFO", combinations=combos
+        )
+    return subdir
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_post_fusions_golden(engine, workdir):
+    subdir = _generate_fusions(engine, workdir)
+    produced = sorted(
+        os.path.relpath(p, workdir) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    assert produced, "generator produced no files"
+
+    for rel in produced:
+        raw = Path(workdir / rel).read_text()
+        if rel.endswith(".json"):
+            data = _sort_string_lists(json.loads(raw))
+            raw = json.dumps(data, indent=2, sort_keys=True)
+        content = _normalize(raw, workdir)
+        _check_golden(f"config_FUSIONS/{engine}/{os.path.basename(rel)}", content)
+
+
+@pytest.mark.parametrize("engine", ["smk", "nf"])
+def test_make_post_fusions_file_set_stable(engine, workdir):
+    subdir = _generate_fusions(engine, workdir)
+    names = sorted(
+        os.path.basename(p) for p in glob.glob(os.path.join(subdir, "*"))
+    )
+    _check_golden(f"config_FUSIONS/{engine}/_filelist.txt", "\n".join(names) + "\n")
+
+
+
 # --------------------------------------------------------------------------- #
 # Cross-engine consistency: the Snakemake and Nextflow generators must expose
 # the same tool matrix, env/bin selection and per-step OPTIONS for one config.
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
new file mode 100644
index 00000000..9b9e93e1
--- /dev/null
+++ b/workflows/starfusion.nf
@@ -0,0 +1,64 @@
+FUSENV = get_always('FUSIONSENV')
+FUSBIN = get_always('FUSIONSBIN')
+FUSREF = get_always('FUSIONSREF')
+FUSREFDIR = "${workflow.workDir}/../"+get_always('FUSIONSREFDIR')
+FUSANNO = get_always('FUSIONSANNO')
+FUSLIB = get_always('FUSIONSLIB')
+
+FUSPARAMS = get_always('starfusion_params_FUSION') ?: ''
+FUSBUILD = get_always('starfusion_params_BUILD') ?: ''
+
+//FUSIONS PROCESSES
+
+process starfusion{
+    conda "$FUSENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$FUSENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_fusions") > 0)      "FUSIONS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"        
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"
+    }
+
+    input:
+    path fls
+
+    output:
+    path "*_fusions", emit: fusions
+    path "log", emit: log
+
+    script:
+    ref = fls[0]
+    anno = fls[1]
+    junction = fls[2]        
+    fn = file(junction).getSimpleName()
+    of = fn+"_fusions"
+    ol = fn+".log"
+    
+    """
+    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; else CTAT=CTAT; mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD &> log; fi; if [[ -s \"${junction}\" ]]; then $FUSBIN --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    """
+}
+
+workflow FUSIONS{ 
+    take: collection
+
+    main:
+
+    MAPPEDSAMPLES = LONGSAMPLES.collect{
+        element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"*.Chimeric.out.junction"
+    }
+
+    mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())  
+    annofile = Channel.fromPath(FUSANNO)
+    genomefile = Channel.fromPath(FUSREF)
+
+    starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+
+    emit:
+    fusions = starfusion.out.fusions
+    logs = starfusion.out.log
+}
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
new file mode 100644
index 00000000..9f3e776d
--- /dev/null
+++ b/workflows/starfusion.smk
@@ -0,0 +1,71 @@
+FBIN, FENV = env_bin_from_config(config, 'FUSIONS')
+
+if not 'star' in combo or not 'star' in scombo:
+        log.warning('STAR-Fusion needs STAR chimeric output, can only be used with STAR in mapping step')
+
+fusopts = tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS']
+fastqmode = str(fusopts.get('FASTQ', "")).lower() in ("1", "true", "yes")
+CTATLIB = fusopts.get('INDEX', "") or os.path.join(REFDIR, "CTAT", FENV)
+
+if not rundedup:
+    rule themall:
+        input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
+else:
+    rule themall:
+        input:  expand("FUSIONS/{combo}/{file}_{type}", combo=combo, file=samplecond(SAMPLES, config), type=['sorted', 'sorted_dedup'])
+
+rule generate_ctat_lib:
+    input:  fa = REFERENCE,
+            anno = ANNOTATION
+    output: lib = directory(CTATLIB),
+            tmpfa = temp(expand("TMP/{fenv}/ctat_ref.fa", fenv=FENV)),
+            tmpanno = temp(expand("TMP/{fenv}/ctat_ref.gtf", fenv=FENV))
+    log:    expand("LOGS/{sets}/{fenv}.ctat.log", sets=SETS, fenv=FENV)
+    conda:  ""+FENV+".yaml"
+    container: "oras://jfallmann/monsda:"+FENV+""
+    threads: MAXTHREAD
+    params: sf = FBIN,
+            bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
+    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && touch {output.tmpfa} {output.tmpanno}; else zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} &> {log}; fi"
+
+if not fastqmode:
+    rule starfusion:
+        input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
+                lib = rules.generate_ctat_lib.output.lib
+        output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+        log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+        conda:  ""+FENV+".yaml"
+        container: "oras://jfallmann/monsda:"+FENV+""
+        threads: MAXTHREAD
+        params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                sf = FBIN
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+else:
+    if paired == 'paired':
+        rule starfusion:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    lib = rules.generate_ctat_lib.output.lib
+            output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            conda:  ""+FENV+".yaml"
+            container: "oras://jfallmann/monsda:"+FENV+""
+            threads: MAXTHREAD
+            params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                    sf = FBIN
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+    else:
+        rule starfusion:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    lib = rules.generate_ctat_lib.output.lib
+            output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            conda:  ""+FENV+".yaml"
+            container: "oras://jfallmann/monsda:"+FENV+""
+            threads: MAXTHREAD
+            params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
+                    sf = FBIN
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"

From 7cd3db7ab043d59adde7ceea0cd4b0fbb2b6ef40 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 7 Jul 2026 15:34:45 +0200
Subject: [PATCH 12/80] profile fixes and cleanup

---
 profile_nextflow/nextflow.config           |   4 +-
 profile_snakemake/cluster_config.yaml      |  26 --
 profile_snakemake/config.v8+.yaml          |  10 +-
 profile_snakemake/config.yaml              |  12 -
 profile_snakemake/slurm-jobscript.sh       |   3 -
 profile_snakemake/slurm-status.py          |  73 -----
 profile_snakemake/slurm-submit-advanced.py | 292 -------------------
 profile_snakemake/slurm-submit.py          |  61 ----
 profile_snakemake/slurm_utils.py           | 317 ---------------------
 9 files changed, 11 insertions(+), 787 deletions(-)
 delete mode 100644 profile_snakemake/cluster_config.yaml
 delete mode 100644 profile_snakemake/config.yaml
 delete mode 100755 profile_snakemake/slurm-jobscript.sh
 delete mode 100755 profile_snakemake/slurm-status.py
 delete mode 100755 profile_snakemake/slurm-submit-advanced.py
 delete mode 100755 profile_snakemake/slurm-submit.py
 delete mode 100644 profile_snakemake/slurm_utils.py

diff --git a/profile_nextflow/nextflow.config b/profile_nextflow/nextflow.config
index bc36eb4b..61d9ba57 100644
--- a/profile_nextflow/nextflow.config
+++ b/profile_nextflow/nextflow.config
@@ -16,10 +16,10 @@ profiles {
 
         // Non-default overrides only – rules that need more than the global defaults.
         process {
-            withName: 'bwa_idx|bwa2_idx|bwameth_idx|hisat2_idx|minimap_idx|segemehl_idx|segemehl3_idx|star_idx' {
+            withName: 'bwa_idx|bwa2_idx|bwameth_idx|hisat2_idx|minimap_idx|segemehl_idx|segemehl3_idx|star_idx|generate_ctat_lib' {
                 memory = { 80.GB * (1 << ((task.attempt ?: 1) - 1)) }
             }
-            withName: 'bwa_mapping|bwa2_mapping|bwameth_mapping|hisat2_mapping|minimap_mapping|segemehl_mapping|segemehl3_mapping|star_mapping' {
+            withName: 'bwa_mapping|bwa2_mapping|bwameth_mapping|hisat2_mapping|minimap_mapping|segemehl_mapping|segemehl3_mapping|star_mapping|starfusion' {
                 memory = { 80.GB * (1 << ((task.attempt ?: 1) - 1)) }
             }
             withName: 'salmon_idx|kallisto_idx' {
diff --git a/profile_snakemake/cluster_config.yaml b/profile_snakemake/cluster_config.yaml
deleted file mode 100644
index f2f619f8..00000000
--- a/profile_snakemake/cluster_config.yaml
+++ /dev/null
@@ -1,26 +0,0 @@
-__default__:
-    account: ${USER} # your account name
-    partition: c # the partition to use
-    time: 1500 # default time (minutes)
-    nodes: 1
-    output: "/SLURMLOG/{rule}.{wildcards}.out"
-    error: "/SLURMLOG/{rule}.{wildcards}.err"
-    #ntasks: 1
-    #mem: 14GB # default memory
-
-generate_index:
-    mem: 200GB
-
-mapping:
-    mem: 200GB
-
-generate_ctat_lib:
-    mem: 200GB
-    time: 2880
-
-starfusion:
-    mem: 100GB
-    time: 1500
-
-multiqc:
-   mem: 30GB
diff --git a/profile_snakemake/config.v8+.yaml b/profile_snakemake/config.v8+.yaml
index a984a4d2..d9af2971 100755
--- a/profile_snakemake/config.v8+.yaml
+++ b/profile_snakemake/config.v8+.yaml
@@ -5,7 +5,9 @@ default-resources:
   slurm_partition: "${SLURM_PARTITION}" # the partition to use
   nodes: 1
   mem_mb: "20000 * (2 ** (attempt - 1))"  
-  runtime: "480 * (2 ** (attempt - 1))"   
+  runtime: "480 * (2 ** (attempt - 1))"  
+  partition: "('c_long' if min(480 * (2 ** (attempt - 1)), 960) > 2880 else 'c_medium' if min(480 * (2 ** (attempt - 1)), 960) > 1440 else 'c_short')"
+  qos: "('long' if min(480 * (2 ** (attempt - 1)), 960) > 2880 else 'medium' if min(480 * (2 ** (attempt - 1)), 960) > 1440 else 'short')" 
 set-resources:
   generate_index:
     mem_mb: "80000 * (2 ** (attempt - 1))"
@@ -41,6 +43,12 @@ set-resources:
   gridss_setupreference:
     mem_mb: "40000 * (2 ** (attempt - 1))"
     threads: 8
+  generate_ctat_lib:
+    mem_mb: "80000 * (2 ** (attempt - 1))"  
+    runtime: "24h"
+  starfusion:
+    mem_mb: "100000 * (2 ** (attempt - 1))"    
+    runtime: "24h"
 jobs: 1000
 keep-going: True
 rerun-incomplete: True
diff --git a/profile_snakemake/config.yaml b/profile_snakemake/config.yaml
deleted file mode 100644
index a4e4edb5..00000000
--- a/profile_snakemake/config.yaml
+++ /dev/null
@@ -1,12 +0,0 @@
-restart-times: 3
-jobscript: "slurm-jobscript.sh"
-cluster-generic-submit-cmd: "slurm-submit.py"
-#cluster-status: "slurm-status.py"
-max-jobs-per-second: 1
-max-status-checks-per-second: 3
-local-cores: 1
-latency-wait: 600
-#use-conda: True
-keep-going: True
-rerun-incomplete: True
-#printshellcmds: True
diff --git a/profile_snakemake/slurm-jobscript.sh b/profile_snakemake/slurm-jobscript.sh
deleted file mode 100755
index 391741ef..00000000
--- a/profile_snakemake/slurm-jobscript.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-# properties = {properties}
-{exec_job}
diff --git a/profile_snakemake/slurm-status.py b/profile_snakemake/slurm-status.py
deleted file mode 100755
index 688c2276..00000000
--- a/profile_snakemake/slurm-status.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-import re
-import subprocess as sp
-import shlex
-import sys
-import time
-import logging
-
-logger = logging.getLogger("__name__")
-
-STATUS_ATTEMPTS = 20
-
-jobid = sys.argv[1]
-
-  # noqa: E999,E225
-cluster = "--cluster=cluster"
-  # noqa: E225
-
-for i in range(STATUS_ATTEMPTS):
-    try:
-        sacct_res = sp.check_output(shlex.split(f"sacct {cluster} -P -b -j {jobid} -n"))
-        res = {
-            x.split("|")[0]: x.split("|")[1]
-            for x in sacct_res.decode().strip().split("\n")
-        }
-        break
-    except sp.CalledProcessError as e:
-        logger.error("sacct process error")
-        logger.error(e)
-    except IndexError as e:
-        pass
-    # Try getting job with scontrol instead in case sacct is misconfigured
-    try:
-        sctrl_res = sp.check_output(
-            shlex.split(f"scontrol {cluster} -o show job {jobid}")
-        )
-        m = re.search(r"JobState=(\w+)", sctrl_res.decode())
-        res = {jobid: m.group(1)}
-        break
-    except sp.CalledProcessError as e:
-        logger.error("scontrol process error")
-        logger.error(e)
-        if i >= STATUS_ATTEMPTS - 1:
-            print("failed")
-            exit(0)
-        else:
-            time.sleep(1)
-
-status = res[jobid]
-
-if status == "BOOT_FAIL":
-    print("failed")
-elif status == "OUT_OF_MEMORY":
-    print("failed")
-elif status.startswith("CANCELLED"):
-    print("failed")
-elif status == "COMPLETED":
-    print("success")
-elif status == "DEADLINE":
-    print("failed")
-elif status == "FAILED":
-    print("failed")
-elif status == "NODE_FAIL":
-    print("failed")
-elif status == "PREEMPTED":
-    print("failed")
-elif status == "TIMEOUT":
-    print("failed")
-# Unclear whether SUSPENDED should be treated as running or failed
-elif status == "SUSPENDED":
-    print("failed")
-else:
-    print("running")
diff --git a/profile_snakemake/slurm-submit-advanced.py b/profile_snakemake/slurm-submit-advanced.py
deleted file mode 100755
index bfe9509f..00000000
--- a/profile_snakemake/slurm-submit-advanced.py
+++ /dev/null
@@ -1,292 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-import re
-import math
-import argparse
-import subprocess
-from snakemake.utils import read_job_properties
-
-
-##############################
-# Helper functions
-##############################
-def _get_default_partition():
-    """Retrieve default partition for cluster"""
-    if "":
-        return ""
-    cmd = "sinfo -O \"partition\""
-    res = subprocess.run(cmd, check=True, shell=True,
-                         stdout=subprocess.PIPE)
-    m = re.search("(?P<partition>\S+)\*", res.stdout.decode(), re.M)
-    partition = m.group("partition")
-    return partition
-
-
-def _get_cluster_configuration(partition):
-    """Retrieve cluster configuration for a partition."""
-    # Retrieve partition info; we tacitly assume we only get one response
-    cmd = " ".join(
-        ["sinfo -e -O \"partition,cpus,memory,time,size,maxcpuspernode\"",
-         "-h -p {}".format(partition)])
-    res = subprocess.run(cmd, check=True, shell=True, stdout=subprocess.PIPE)
-    m = re.search("(?P<partition>\S+)\s+(?P<cpus>\d+)\s+(?P<memory>\S+)\s+((?P<days>\d+)-)?(?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d+)\s+(?P<size>\S+)\s+(?P<maxcpus>\S+)",
-                  res.stdout.decode())
-    if m is None:
-        m = re.search("(?P<partition>\S+)\s+(?P<cpus>\d+)\s+(?P<memory>\S+)\s+(?P<time>\S+)\s+(?P<size>\S+)\s+(?P<maxcpus>\S+)",
-                      res.stdout.decode())
-    d = m.groupdict()
-    if not 'days' in d or not d['days'] or 'time' in d and d['time'] == 'infinite':
-        d['days'] = 30
-        d['hours'] = d['minutes'] = d['seconds'] = 0
-    d["time"] = int(d['days']) * 24 * 60 + \
-        int(d['hours']) * 60 + int(d['minutes']) + \
-        math.ceil(int(d['seconds']) / 60)
-    return d
-
-
-def _get_features_and_memory(partition):
-    """Retrieve features and memory for a partition in the cluster
-    configuration. """
-    cmd = " ".join(
-        ["sinfo -e -O \"memory,features_act\"",
-         "-h -p {}".format(partition)])
-    res = subprocess.run(cmd, check=True, shell=True, stdout=subprocess.PIPE)
-    mem_feat = []
-    for x in res.stdout.decode().split("\n"):
-        if not re.search("^\d+", x):
-            continue
-        m = re.search("^(?P<mem>\d+)\s+(?P<feat>\S+)", x)
-        mem_feat.append({'mem': m.groupdict()["mem"],
-                         'features': m.groupdict()["feat"].split(",")})
-    return mem_feat
-
-
-def _get_available_memory(mem_feat, constraints=None):
-    """Get available memory
-
-    If constraints are given, parse constraint string into array of
-    constraints and compare them to active features. Currently only
-    handles comma-separated strings and not the more advanced
-    constructs described in the slurm manual.
-
-    Else, the minimum memory for a given partition is returned.
-
-    """
-    if constraints is None:
-        return min([int(x['mem']) for x in mem_feat])
-    try:
-        constraint_set = set(constraints.split(","))
-        for x in mem_feat:
-            if constraint_set.intersection(x["features"]) == constraint_set:
-                return int(x["mem"])
-    except Exception as e:
-        print(e)
-        raise
-
-
-def _update_memory_and_ntasks(arg_dict, MEMORY_PER_CPU, MEMORY_PER_PARTITION):
-    """Given a one-node job, update memory and ntasks if the requested
-    configuration is unavailable"""
-    if arg_dict["mem"] is not None:
-        arg_dict["mem"] = min(int(arg_dict["mem"]),
-                              MEMORY_PER_PARTITION)
-        AVAILABLE_MEM = arg_dict["ntasks"] * MEMORY_PER_CPU
-        if arg_dict["mem"] > AVAILABLE_MEM:
-            arg_dict["ntasks"] = int(math.ceil(arg_dict["mem"] /
-                                               MEMORY_PER_CPU))
-    arg_dict["ntasks"] = min(int(config["cpus"]),
-                             int(arg_dict["ntasks"]))
-
-##############################
-# Main script
-##############################
-parser = argparse.ArgumentParser(add_help=False)
-parser.add_argument(
-    "--help", help="Display help message.", action="store_true")
-parser.add_argument(
-    "positional", action="append",
-    nargs="?", metavar="POS",
-    help="additional arguments not in slurm parser group to pass to sbatch")
-
-# A subset of SLURM-specific arguments. Note that the parser is used
-# implicitly in that the parsed arguments are used to construct a
-# dictionary of arguments to be processed. Specific arguments can be
-# modified via the cluster configuration file.
-slurm_parser = parser.add_argument_group("slurm-specific arguments")
-slurm_parser.add_argument(
-    "-a", "--array", help="job array index values")
-slurm_parser.add_argument(
-    "-A", "--account", help="charge job to specified account")
-slurm_parser.add_argument(
-    "--begin", help="defer job until HH:MM MM/DD/YY")
-slurm_parser.add_argument(
-    "-c", "--cpus-per-task", help="number of cpus required per task",
-    type=int, default=1)
-slurm_parser.add_argument(
-    "-d", "--dependency",
-    help="defer job until condition on jobid is satisfied")
-slurm_parser.add_argument(
-    "-D", "--workdir", help="set working directory for batch script")
-slurm_parser.add_argument(
-    "-e", "--error", help="file for batch script's standard error",
-    default="" if "" else None)
-slurm_parser.add_argument(
-    "-J", "--job-name", help="name of job")
-slurm_parser.add_argument(
-    "--mail-type", help="notify on state change: BEGIN, END, FAIL or ALL")
-slurm_parser.add_argument(
-    "--mail-user", help="who to send email notification for job state changes")
-slurm_parser.add_argument(
-    "-n", "--ntasks", help="number of tasks to run", type=int, default=1)
-slurm_parser.add_argument(
-    "-N", "--nodes", help="number of nodes on which to run (N = min[-max])",
-    type=int)
-slurm_parser.add_argument(
-    "-o", "--output", help="file for batch script's standard output",
-    default="" if "" else None)
-slurm_parser.add_argument(
-    "-p", "--partition", help="partition requested",
-    default=_get_default_partition(), type=str)
-slurm_parser.add_argument(
-    "-q", "--qos", help="quality of service")
-slurm_parser.add_argument(
-    "-Q", "--quiet", help="quiet mode (suppress informational messages)")
-slurm_parser.add_argument(
-    "-t", "--time", help="time limit")
-slurm_parser.add_argument(
-    "--wrap", help="wrap command string in a sh script and submit")
-slurm_parser.add_argument(
-    "-C", "--constraint", help="specify a list of constraints")
-slurm_parser.add_argument(
-    "--mem", help="minimum amount of real memory")
-
-opt_keys = ["array", "account", "begin", "cpus_per_task",
-            "dependency", "workdir", "error", "job_name", "mail_type",
-            "mail_user", "ntasks", "nodes", "output", "partition",
-            "quiet", "time", "wrap", "constraint", "mem"]
-
-args = parser.parse_args()
-
-if args.help:
-    parser.print_help()
-    sys.exit(0)
-
-jobscript = sys.argv[-1]
-job_properties = read_job_properties(jobscript)
-
-extras = ""
-if args.positional:
-    for m in args.positional:
-        if m is not None:
-            extras = extras + " " + m
-
-arg_dict = dict(args.__dict__)
-
-# Set default account
-if arg_dict["account"] is None:
-    if "" != "":
-        arg_dict["account"] = ""
-
-
-# Ensure output folder for Slurm log files exist.
-# This is a bit hacky; will run for every Slurm submission...
-if arg_dict["output"] is not None:
-    if not os.path.exists(os.path.dirname(arg_dict["output"])):
-        os.makedirs(os.path.dirname(arg_dict["output"]))
-if arg_dict["error"] is not None:
-    if not os.path.exists(os.path.dirname(arg_dict["error"])):
-        os.makedirs(os.path.dirname(arg_dict["error"]))
-
-
-# Process resources
-if "resources" in job_properties:
-    resources = job_properties["resources"]
-    if arg_dict["time"] is None:
-        if "runtime" in resources:
-            arg_dict["time"] = resources["runtime"]
-        elif "walltime" in resources:
-            arg_dict["time"] = resources["walltime"]
-    if arg_dict["mem"] is None:
-        if "mem" in resources:
-            arg_dict["mem"] = resources["mem"]
-        elif "mem_mb" in resources:
-            arg_dict["mem"] = resources["mem_mb"]
-
-# Threads
-if "threads" in job_properties:
-    arg_dict["ntasks"] = job_properties["threads"]
-
-
-# Process cluster configuration. Note that setting time, ntasks, and
-# mem will override any setting in resources. It is assumed that the
-# cluster configuration parameters are named according to the sbatch
-# long options names
-cluster_config = job_properties.get("cluster", {})
-arg_dict.update(job_properties.get("cluster", {}))
-
-# Determine partition with features. If no constraints have been set,
-# select the partition with lowest memory
-try:
-    part = arg_dict["partition"]
-    config = _get_cluster_configuration(part)
-    mem_feat = _get_features_and_memory(part)
-    MEMORY_PER_PARTITION = _get_available_memory(mem_feat,
-                                                 arg_dict["constraint"])
-    MEMORY_PER_CPU = MEMORY_PER_PARTITION / int(config["cpus"])
-except subprocess.CalledProcessError as e:
-    print(e)
-    raise e
-except Exception as e:
-    print(e)
-    raise e
-
-
-# Update time. If requested time is larger than maximum allowed time,
-# reset
-try:
-    if arg_dict["time"] is not None:
-        arg_dict["time"] = min(int(config["time"]), int(arg_dict["time"]))
-except Exception as e:
-    print(e)
-    raise e
-
-
-# Adjust memory in the single-node case only; getting the
-# functionality right for multi-node multi-cpu jobs requires more
-# development
-if arg_dict["nodes"] is None or int(arg_dict["nodes"]) == 1:
-    _update_memory_and_ntasks(arg_dict, MEMORY_PER_CPU,
-                              MEMORY_PER_PARTITION)
-else:
-    if int(arg_dict["ntasks"]) == 1:
-        # Allocate at least as many tasks as requested nodes
-        arg_dict["ntasks"] = int(arg_dict["nodes"])
-
-
-opts = ""
-for k, v in arg_dict.items():
-    if k not in opt_keys:
-        continue
-    if v is not None:
-        opts += " --{} \"{}\" ".format(k.replace("_", "-"), v)
-
-if arg_dict["wrap"] is not None:
-    cmd = "sbatch {opts}".format(opts=opts)
-else:
-    cmd = "sbatch {opts} {extras}".format(opts=opts, extras=extras)
-
-try:
-    res = subprocess.run(cmd, check=True, shell=True, stdout=subprocess.PIPE)
-except subprocess.CalledProcessError as e:
-    raise e
-
-# Get jobid
-res = res.stdout.decode()
-try:
-    m = re.search("Submitted batch job (\d+)", res)
-    jobid = m.group(1)
-    print(jobid)
-except Exception as e:
-    print(e)
-    raise
diff --git a/profile_snakemake/slurm-submit.py b/profile_snakemake/slurm-submit.py
deleted file mode 100755
index 78da6d26..00000000
--- a/profile_snakemake/slurm-submit.py
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""
-Snakemake SLURM submit script.
-"""
-import warnings  # use warnings.warn() rather than print() to output info in this script
-
-from snakemake.utils import read_job_properties
-
-import slurm_utils
-
-# cookiecutter arguments
-SBATCH_DEFAULTS = """ """
-CLUSTER_CONFIG = "cluster_config.yaml"
-ADVANCED_ARGUMENT_CONVERSION = {"yes": True, "no": False}[
-    "no"
-]
-
-RESOURCE_MAPPING = {
-    "time": ("time", "runtime", "walltime"),
-    "mem": ("mem", "mem_mb", "ram", "memory"),
-    "mem-per-cpu": ("mem-per-cpu", "mem_per_cpu", "mem_per_thread"),
-    "nodes": ("nodes", "nnodes"),
-}
-
-# parse job
-jobscript = slurm_utils.parse_jobscript()
-job_properties = read_job_properties(jobscript)
-
-sbatch_options = {}
-cluster_config = slurm_utils.load_cluster_config(CLUSTER_CONFIG)
-
-# 1) sbatch default arguments
-sbatch_options.update(slurm_utils.parse_sbatch_defaults(SBATCH_DEFAULTS))
-
-# 2) cluster_config defaults
-sbatch_options.update(cluster_config["__default__"])
-
-# 3) Convert resources (no unit conversion!) and threads
-sbatch_options.update(
-    slurm_utils.convert_job_properties(job_properties, RESOURCE_MAPPING)
-)
-
-# 4) cluster_config for particular rule
-sbatch_options.update(cluster_config.get(job_properties.get("rule"), {}))
-
-# 5) cluster_config options
-sbatch_options.update(job_properties.get("cluster", {}))
-
-# 6) Advanced conversion of parameters
-if ADVANCED_ARGUMENT_CONVERSION:
-    sbatch_options = slurm_utils.advanced_argument_conversion(sbatch_options)
-
-# 7) Format pattern in snakemake style
-sbatch_options = slurm_utils.format_values(sbatch_options, job_properties)
-
-# ensure sbatch output dirs exist
-for o in ("output", "error"):
-    slurm_utils.ensure_dirs_exist(sbatch_options[o]) if o in sbatch_options else None
-
-# submit job and echo id back to Snakemake (must be the only stdout)
-print(slurm_utils.submit_job(jobscript, **sbatch_options))
diff --git a/profile_snakemake/slurm_utils.py b/profile_snakemake/slurm_utils.py
deleted file mode 100644
index ab1d0834..00000000
--- a/profile_snakemake/slurm_utils.py
+++ /dev/null
@@ -1,317 +0,0 @@
-#!/usr/bin/env python3
-import os
-import sys
-from os.path import dirname
-import re
-import math
-import argparse
-import subprocess as sp
-from io import StringIO
-
-from snakemake import io
-from snakemake.io import Wildcards
-from snakemake.utils import SequenceFormatter
-from snakemake.utils import AlwaysQuotedFormatter
-from snakemake.utils import QuotedFormatter
-from snakemake.exceptions import WorkflowError
-from snakemake.logging import logger
-
-
-def parse_jobscript():
-    """Minimal CLI to require/only accept single positional argument."""
-    p = argparse.ArgumentParser(description="SLURM snakemake submit script")
-    p.add_argument("jobscript", help="Snakemake jobscript with job properties.")
-    return p.parse_args().jobscript
-
-
-def parse_sbatch_defaults(parsed):
-    """Unpack SBATCH_DEFAULTS."""
-    d = parsed.split() if type(parsed) == str else parsed
-    args = {}
-    for keyval in [a.split("=") for a in d]:
-        k = keyval[0].strip().strip("-")
-        v = keyval[1].strip() if len(keyval) == 2 else None
-        args[k] = v
-    return args
-
-
-def load_cluster_config(path):
-    """Load config to dict
-
-    Load configuration to dict either from absolute path or relative
-    to profile dir.
-    """
-    if path:
-        path = os.path.join(dirname(__file__), os.path.expandvars(path))
-        dcc = io.load_configfile(path)
-    else:
-        dcc = {}
-    if "__default__" not in dcc:
-        dcc["__default__"] = {}
-    return dcc
-
-
-# adapted from format function in snakemake.utils
-def format(_pattern, _quote_all=False, **kwargs):  # noqa: A001
-    """Format a pattern in Snakemake style.
-    This means that keywords embedded in braces are replaced by any variable
-    values that are available in the current namespace.
-    """
-    fmt = SequenceFormatter(separator=" ")
-    if _quote_all:
-        fmt.element_formatter = AlwaysQuotedFormatter()
-    else:
-        fmt.element_formatter = QuotedFormatter()
-    try:
-        return fmt.format(_pattern, **kwargs)
-    except KeyError as ex:
-        raise NameError(
-            f"The name {ex} is unknown in this context. Please "
-            "make sure that you defined that variable. "
-            "Also note that braces not used for variable access "
-            "have to be escaped by repeating them "
-        )
-
-
-#  adapted from Job.format_wildcards in snakemake.jobs
-def format_wildcards(string, job_properties):
-    """ Format a string with variables from the job. """
-
-    class Job(object):
-        def __init__(self, job_properties):
-            for key in job_properties:
-                setattr(self, key, job_properties[key])
-
-    job = Job(job_properties)
-    if "params" in job_properties:
-        job._format_params = Wildcards(fromdict=job_properties["params"])
-    else:
-        job._format_params = None
-    if "wildcards" in job_properties:
-        job._format_wildcards = Wildcards(fromdict=job_properties["wildcards"])
-    else:
-        job._format_wildcards = None
-    _variables = dict()
-    _variables.update(
-        dict(params=job._format_params, wildcards=job._format_wildcards)
-    )
-    if hasattr(job, "rule"):
-        _variables.update(dict(rule=job.rule))
-    try:
-        return format(string, **_variables)
-    except NameError as ex:
-        raise WorkflowError(
-            "NameError with group job {}: {}".format(job.jobid, str(ex))
-        )
-    except IndexError as ex:
-        raise WorkflowError(
-            "IndexError with group job {}: {}".format(job.jobid, str(ex))
-        )
-
-
-# adapted from ClusterExecutor.cluster_params function in snakemake.executor
-def format_values(dictionary, job_properties):
-    formatted = dictionary.copy()
-    for key, value in list(formatted.items()):
-        if isinstance(value, str):
-            try:
-                formatted[key] = format_wildcards(value, job_properties)
-            except NameError as e:
-                msg = "Failed to format cluster config " "entry for job {}.".format(
-                    job_properties["rule"]
-                )
-                raise WorkflowError(msg, e)
-    return formatted
-
-
-def convert_job_properties(job_properties, resource_mapping=None):
-    options = {}
-    if resource_mapping is None:
-        resource_mapping = {}
-    resources = job_properties.get("resources", {})
-    for k, v in resource_mapping.items():
-        options.update({k: resources[i] for i in v if i in resources})
-
-    if "threads" in job_properties:
-        options["cpus-per-task"] = job_properties["threads"]
-    return options
-
-
-def ensure_dirs_exist(path):
-    """Ensure output folder for Slurm log files exist."""
-    di = dirname(path)
-    if di == "":
-        return
-    if not os.path.exists(di):
-        os.makedirs(di, exist_ok=True)
-    return
-
-
-def format_sbatch_options(**sbatch_options):
-    """Format sbatch options"""
-    options = []
-    for k, v in sbatch_options.items():
-        val = ""
-        if v is not None:
-            val = f"={v}"
-        options.append(f"--{k}{val}")
-    return options
-
-
-def submit_job(jobscript, **sbatch_options):
-    """Submit jobscript and return jobid."""
-    options = format_sbatch_options(**sbatch_options)
-    try:
-        cmd = ["sbatch"] + ["--parsable"] + options + [jobscript]
-        res = sp.check_output(cmd)
-    except sp.CalledProcessError as e:
-        raise e
-    # Get jobid
-    res = res.decode()
-    try:
-        jobid = re.search(r"(\d+)", res).group(1)
-    except Exception as e:
-        raise e
-    return jobid
-
-
-def advanced_argument_conversion(arg_dict):
-    """Experimental adjustment of sbatch arguments to the given or default partition."""
-    # Currently not adjusting for multiple node jobs
-    nodes = int(arg_dict.get("nodes", 1))
-    if nodes > 1:
-        return arg_dict
-    partition = arg_dict.get("partition", None) or _get_default_partition()
-    constraint = arg_dict.get("constraint", None)
-    ncpus = int(arg_dict.get("cpus-per-task", 1))
-    runtime = arg_dict.get("time", None)
-    config = _get_cluster_configuration(partition, constraint, arg_dict.get("mem", 0))
-    mem = arg_dict.get("mem", ncpus * min(config["MEMORY_PER_CPU"]))
-    if mem > max(config["MEMORY"]):
-        logger.info(
-            f"requested memory ({mem}) > max memory ({max(config['MEMORY'])}); "
-            "adjusting memory settings"
-        )
-        mem = max(config["MEMORY"])
-
-    # Calculate available memory as defined by the number of requested
-    # cpus times memory per cpu
-    AVAILABLE_MEM = ncpus * min(config["MEMORY_PER_CPU"])
-    # Add additional cpus if memory is larger than AVAILABLE_MEM
-    if mem > AVAILABLE_MEM:
-        logger.info(
-            f"requested memory ({mem}) > "
-            f"ncpus x MEMORY_PER_CPU ({AVAILABLE_MEM}); "
-            "trying to adjust number of cpus up"
-        )
-        ncpus = int(math.ceil(mem / min(config["MEMORY_PER_CPU"])))
-    if ncpus > max(config["CPUS"]):
-        logger.info(
-            f"ncpus ({ncpus}) > available cpus ({max(config['CPUS'])}); "
-            "adjusting number of cpus down"
-        )
-        ncpus = min(int(max(config["CPUS"])), ncpus)
-    adjusted_args = {"mem": int(mem), "cpus-per-task": ncpus}
-
-    # Update time. If requested time is larger than maximum allowed time, reset
-    if runtime:
-        runtime = time_to_minutes(runtime)
-        time_limit = max(config["TIMELIMIT_MINUTES"])
-        if runtime > time_limit:
-            logger.info(
-                f"time (runtime) > time limit {time_limit}; " "adjusting time down"
-            )
-            adjusted_args["time"] = time_limit
-
-    # update and return
-    arg_dict.update(adjusted_args)
-    return arg_dict
-
-
-timeformats = [
-    re.compile(r"^(?P<days>\d+)-(?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d+)$"),
-    re.compile(r"^(?P<days>\d+)-(?P<hours>\d+):(?P<minutes>\d+)$"),
-    re.compile(r"^(?P<days>\d+)-(?P<hours>\d+)$"),
-    re.compile(r"^(?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d+)$"),
-    re.compile(r"^(?P<minutes>\d+):(?P<seconds>\d+)$"),
-    re.compile(r"^(?P<minutes>\d+)$"),
-]
-
-
-def time_to_minutes(time):
-    """Convert time string to minutes.
-
-    According to slurm:
-
-      Acceptable time formats include "minutes", "minutes:seconds",
-      "hours:minutes:seconds", "days-hours", "days-hours:minutes"
-      and "days-hours:minutes:seconds".
-
-    """
-    if not isinstance(time, str):
-        time = str(time)
-    d = {"days": 0, "hours": 0, "minutes": 0, "seconds": 0}
-    regex = list(filter(lambda regex: regex.match(time) is not None, timeformats))
-    if len(regex) == 0:
-        return
-    assert len(regex) == 1, "multiple time formats match"
-    m = regex[0].match(time)
-    d.update(m.groupdict())
-    minutes = (
-        int(d["days"]) * 24 * 60
-        + int(d["hours"]) * 60
-        + int(d["minutes"])
-        + math.ceil(int(d["seconds"]) / 60)
-    )
-    assert minutes > 0, "minutes has to be greater than 0"
-    return minutes
-
-
-def _get_default_partition():
-    """Retrieve default partition for cluster"""
-    res = sp.check_output(["sinfo", "-O", "partition"])
-    m = re.search(r"(?P<partition>\S+)\*", res.decode(), re.M)
-    partition = m.group("partition")
-    return partition
-
-
-def _get_cluster_configuration(partition, constraints=None, memory=0):
-    """Retrieve cluster configuration.
-
-    Retrieve cluster configuration for a partition filtered by
-    constraints, memory and cpus
-
-    """
-    try:
-        import pandas as pd
-    except ImportError:
-        print(
-            "Error: currently advanced argument conversion "
-            "depends on 'pandas'.", file=sys.stderr
-        )
-        sys.exit(1)
-
-    if constraints:
-        constraint_set = set(constraints.split(","))
-    cmd = ["sinfo", "-e", "-o", "%all", "-p", partition]
-    try:
-        output = sp.Popen(" ".join(cmd), shell=True, stdout=sp.PIPE).communicate()
-    except Exception as e:
-        print(e)
-        raise
-    data = re.sub(" \\|", "|", output[0].decode())
-    df = pd.read_csv(StringIO(data), sep="|")
-    try:
-        df["TIMELIMIT_MINUTES"] = df["TIMELIMIT"].apply(time_to_minutes)
-        df["MEMORY_PER_CPU"] = df["MEMORY"] / df["CPUS"]
-        df["FEATURE_SET"] = df["AVAIL_FEATURES"].str.split(",").apply(set)
-    except Exception as e:
-        print(e)
-        raise
-    if constraints:
-        constraint_set = set(constraints.split(","))
-        i = df["FEATURE_SET"].apply(lambda x: len(x.intersection(constraint_set)) > 0)
-        df = df.loc[i]
-    memory = min(memory, max(df["MEMORY"]))
-    df = df.loc[df["MEMORY"] >= memory]
-    return df

From e04c81cae67d64ec61296e2c38bf71416679ad51 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 8 Jul 2026 11:59:21 +0200
Subject: [PATCH 13/80] fusion fix in header and tests

---
 ...rimgalore-picard-star_DTU_dexseq_subsnake.smk | 15 +++++++++++++++
 ...imgalore-picard-star_DTU_drimseq_subsnake.smk | 15 +++++++++++++++
 ...-trimgalore-picard-star_DTU_spit_subsnake.smk | 15 +++++++++++++++
 ...e-picard-star_FUSIONS_starfusion_subsnake.smk | 15 +++++++++++++++
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk    | 15 +++++++++++++++
 .../Test_fastqc-bbduk-picard-star_subsnake.smk   | 15 +++++++++++++++
 .../Test_fastqc-cutadapt-picard-bwa_subsnake.smk | 15 +++++++++++++++
 ...Test_fastqc-cutadapt-picard-star_subsnake.smk | 15 +++++++++++++++
 ...est_fastqc-trimgalore-picard-bwa_subsnake.smk | 15 +++++++++++++++
 ...st_fastqc-trimgalore-picard-star_subsnake.smk | 15 +++++++++++++++
 workflows/header.smk                             | 16 ++++++++++++++++
 11 files changed, 166 insertions(+)

diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
index acaeaab8..c1c00c14 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index c13e2857..e4c3e7a1 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index f2ae1387..90379170 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index 04411316..fbacf1ac 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index dfa62d8d..3266e586 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index 99981727..570357dc 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index e93ded03..15628ca3 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index d8015aa1..8ea65245 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index c80ab9ea..e0a745a3 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 71c0b7f1..558246f5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -271,6 +271,21 @@ if 'CIRCS' in config:
         ANNOTATION = CANNO
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 combo = ''
 if ANNOTATION:
     log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
diff --git a/workflows/header.smk b/workflows/header.smk
index 3f852471..46cf3ebe 100644
--- a/workflows/header.smk
+++ b/workflows/header.smk
@@ -302,6 +302,22 @@ if 'CIRCS' in config:
     else:
         ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
 
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+
 
 combo = ''
 

From f8c3f1d0719ffda9d3ec0009108a797f33f81fee Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 8 Jul 2026 13:02:31 +0200
Subject: [PATCH 14/80] fixed ctat ref detection, tests update, footer fix

---
 ...stqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk |  2 +-
 ...tqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk |  2 +-
 ...fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk |  2 +-
 ...rimgalore-picard-star_FUSIONS_starfusion_subflow.nf |  2 +-
 ...mgalore-picard-star_FUSIONS_starfusion_subsnake.smk | 10 +++++-----
 .../smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk      |  2 +-
 .../smk/Test_fastqc-bbduk-picard-star_subsnake.smk     |  2 +-
 .../smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk   |  2 +-
 .../smk/Test_fastqc-cutadapt-picard-star_subsnake.smk  |  2 +-
 .../smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk |  2 +-
 .../Test_fastqc-trimgalore-picard-star_subsnake.smk    |  2 +-
 workflows/footer.smk                                   |  2 +-
 workflows/starfusion.nf                                |  2 +-
 workflows/starfusion.smk                               |  8 ++++----
 14 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
index c1c00c14..cc787fc9 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -492,6 +492,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index e4c3e7a1..e89d5750 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -521,6 +521,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index 90379170..e8812b57 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -513,6 +513,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index acd2e5fe..9aeb264e 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -70,7 +70,7 @@ process starfusion{
     of = fn+"_fusions"
     ol = fn+".log"
     """
-    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; else CTAT=CTAT; mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} &> log; fi; if [[ -s \"${junction}\" ]]; then ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
     """
 }
 workflow FUSIONS{ 
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index fbacf1ac..1212a53e 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -325,7 +325,7 @@ rule generate_ctat_lib:
     threads: MAXTHREAD
     params: sf = FBIN,
             bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
-    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && touch {output.tmpfa} {output.tmpanno}; else zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} &> {log}; fi"
+    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" || -f \"{output.lib}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && mkdir -p {output.lib} && touch {output.tmpfa} {output.tmpanno}; else ( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}; fi"
 if not fastqmode:
     rule starfusion:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
@@ -338,7 +338,7 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir $GLIB -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:
@@ -353,7 +353,7 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
@@ -366,7 +366,7 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
 
 
 ## Queue-agnostic fallback resources for all rules.
@@ -397,6 +397,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index 3266e586..67865a8a 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -849,6 +849,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index 570357dc..de008df0 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -764,6 +764,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index 15628ca3..a1a7020c 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -849,6 +849,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index 8ea65245..cdebcde8 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -764,6 +764,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index e0a745a3..02c31bc5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -856,6 +856,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 558246f5..ba75a675 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -771,6 +771,6 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
 
 
diff --git a/workflows/footer.smk b/workflows/footer.smk
index 17081eeb..adb36f54 100644
--- a/workflows/footer.smk
+++ b/workflows/footer.smk
@@ -34,4 +34,4 @@ for _rule in workflow.rules:
 onsuccess:
     print("Workflow finished, no error")
 onerror:
-	print("ERROR: "+str({log}))
+	print("ERROR: "+str(log))
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index 9b9e93e1..8801b421 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -39,7 +39,7 @@ process starfusion{
     ol = fn+".log"
     
     """
-    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; else CTAT=CTAT; mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD &> log; fi; if [[ -s \"${junction}\" ]]; then $FUSBIN --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then $FUSBIN --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
     """
 }
 
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index 9f3e776d..8c0040c9 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -26,7 +26,7 @@ rule generate_ctat_lib:
     threads: MAXTHREAD
     params: sf = FBIN,
             bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
-    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && touch {output.tmpfa} {output.tmpanno}; else zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} &> {log}; fi"
+    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" || -f \"{output.lib}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && mkdir -p {output.lib} && touch {output.tmpfa} {output.tmpanno}; else ( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}; fi"
 
 if not fastqmode:
     rule starfusion:
@@ -40,7 +40,7 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir $GLIB -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:
@@ -55,7 +55,7 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
@@ -68,4 +68,4 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"

From 7ae5c701626136aad7f363f279d9b41dd4083187 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 8 Jul 2026 14:59:13 +0200
Subject: [PATCH 15/80] ctatlibdir detection fix

---
 ...icard-star_FUSIONS_starfusion_subsnake.smk | 24 ++++++++++++-----
 workflows/starfusion.smk                      | 27 ++++++++++++++-----
 2 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index 1212a53e..d85e5fbc 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -307,6 +307,12 @@ if not 'star' in combo or not 'star' in scombo:
 fusopts = tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS']
 fastqmode = str(fusopts.get('FASTQ', "")).lower() in ("1", "true", "yes")
 CTATLIB = fusopts.get('INDEX', "") or os.path.join(REFDIR, "CTAT", FENV)
+if os.path.isfile(os.path.join(CTATLIB, "ref_annot.gtf")):
+    CTATGENOMEDIR = CTATLIB
+elif os.path.isfile(os.path.join(CTATLIB, "ctat_genome_lib_build_dir", "ref_annot.gtf")):
+    CTATGENOMEDIR = os.path.join(CTATLIB, "ctat_genome_lib_build_dir")
+else:
+    CTATGENOMEDIR = None
 if not rundedup:
     rule themall:
         input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
@@ -325,11 +331,15 @@ rule generate_ctat_lib:
     threads: MAXTHREAD
     params: sf = FBIN,
             bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
-    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" || -f \"{output.lib}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && mkdir -p {output.lib} && touch {output.tmpfa} {output.tmpanno}; else ( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}; fi"
+    shell:  "( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}"
+if CTATGENOMEDIR is not None:
+    ctat_lib_input = CTATGENOMEDIR
+else:
+    ctat_lib_input = rules.generate_ctat_lib.output.lib
 if not fastqmode:
     rule starfusion:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
-                lib = rules.generate_ctat_lib.output.lib
+                lib = ctat_lib_input
         output: fusions = "FUSIONS/{combo}/{file}_fusions",
                 outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -338,13 +348,13 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir $GLIB -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                     r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
-                    lib = rules.generate_ctat_lib.output.lib
+                    lib = ctat_lib_input
             output: fusions = "FUSIONS/{combo}/{file}_fusions",
                     outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -353,11 +363,11 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
-                    lib = rules.generate_ctat_lib.output.lib
+                    lib = ctat_lib_input
             output: fusions = "FUSIONS/{combo}/{file}_fusions",
                     outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -366,7 +376,7 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index 8c0040c9..df96adae 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -7,6 +7,13 @@ fusopts = tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS']
 fastqmode = str(fusopts.get('FASTQ', "")).lower() in ("1", "true", "yes")
 CTATLIB = fusopts.get('INDEX', "") or os.path.join(REFDIR, "CTAT", FENV)
 
+if os.path.isfile(os.path.join(CTATLIB, "ref_annot.gtf")):
+    CTATGENOMEDIR = CTATLIB
+elif os.path.isfile(os.path.join(CTATLIB, "ctat_genome_lib_build_dir", "ref_annot.gtf")):
+    CTATGENOMEDIR = os.path.join(CTATLIB, "ctat_genome_lib_build_dir")
+else:
+    CTATGENOMEDIR = None
+
 if not rundedup:
     rule themall:
         input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
@@ -26,12 +33,18 @@ rule generate_ctat_lib:
     threads: MAXTHREAD
     params: sf = FBIN,
             bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
-    shell:  "if [[ -f \"{output.lib}/ref_annot.gtf\" || -f \"{output.lib}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then echo \"Found CTAT genome lib, continue with STAR-Fusion\" &> {log} && mkdir -p {output.lib} && touch {output.tmpfa} {output.tmpanno}; else ( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}; fi"
+    shell:  "( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}"
+
+if CTATGENOMEDIR is not None:
+    ctat_lib_input = CTATGENOMEDIR
+else:
+    ctat_lib_input = rules.generate_ctat_lib.output.lib
+
 
 if not fastqmode:
     rule starfusion:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
-                lib = rules.generate_ctat_lib.output.lib
+                lib = ctat_lib_input
         output: fusions = "FUSIONS/{combo}/{file}_fusions",
                 outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -40,13 +53,13 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir $GLIB -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                     r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
-                    lib = rules.generate_ctat_lib.output.lib
+                    lib = ctat_lib_input
             output: fusions = "FUSIONS/{combo}/{file}_fusions",
                     outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -55,11 +68,11 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
-                    lib = rules.generate_ctat_lib.output.lib
+                    lib = ctat_lib_input
             output: fusions = "FUSIONS/{combo}/{file}_fusions",
                     outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
@@ -68,4 +81,4 @@ else:
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "GLIB={input.lib}; if [[ -f \"$GLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then GLIB=$GLIB/ctat_genome_lib_build_dir; fi; {params.sf} --genome_lib_dir $GLIB --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"

From f90339b9d337d5a3ae21d9efc06cd7c32e496437 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 8 Jul 2026 17:07:48 +0200
Subject: [PATCH 16/80] chr naming convention fix for fusion detection

---
 ...fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf | 2 +-
 ...stqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk | 3 ++-
 workflows/starfusion.nf                                        | 2 +-
 workflows/starfusion.smk                                       | 3 ++-
 4 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index 9aeb264e..3024e8ef 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -70,7 +70,7 @@ process starfusion{
     of = fn+"_fusions"
     ol = fn+".log"
     """
-    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
     """
 }
 workflow FUSIONS{ 
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index d85e5fbc..febe13cf 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -341,6 +341,7 @@ if not fastqmode:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
                 lib = ctat_lib_input
         output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction",
                 outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
         conda:  "<REPO>/envs/"+FENV+".yaml"
@@ -348,7 +349,7 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index 8801b421..9eeee414 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -39,7 +39,7 @@ process starfusion{
     ol = fn+".log"
     
     """
-    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then $FUSBIN --genome_lib_dir \$CTAT -J ${junction} --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
     """
 }
 
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index df96adae..a56a581b 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -46,6 +46,7 @@ if not fastqmode:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
                 lib = ctat_lib_input
         output: fusions = "FUSIONS/{combo}/{file}_fusions",
+                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction",
                 outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
         conda:  ""+FENV+".yaml"
@@ -53,7 +54,7 @@ if not fastqmode:
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then {params.sf} --genome_lib_dir {input.lib} -J {input.junction} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
 else:
     if paired == 'paired':
         rule starfusion:

From ecd4845ab9ed325430f58b1b7d4e36e4a1d9c78e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 9 Jul 2026 14:43:04 +0200
Subject: [PATCH 17/80] fixed fusion paths

---
 ...-picard-star_FUSIONS_starfusion_subflow.nf | 10 ++++----
 ...icard-star_FUSIONS_starfusion_subsnake.smk | 24 +++++++++----------
 workflows/starfusion.nf                       | 10 ++++----
 workflows/starfusion.smk                      | 24 +++++++++----------
 4 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index 3024e8ef..32d64d1b 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -54,23 +54,23 @@ process starfusion{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_fusions") > 0)      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"        
-        else if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
+        if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
     path fls
     output:
-    path "*_fusions", emit: fusions
+    path "${fn}_starfusion/*", emit: fusions
     path "log", emit: log
     script:
     ref = fls[0]
     anno = fls[1]
     junction = fls[2]        
     fn = file(junction).getSimpleName()
-    of = fn+"_fusions"
+    od = fn+"_starfusion"
     ol = fn+".log"
     """
-    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir TMP --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
     """
 }
 workflow FUSIONS{ 
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index febe13cf..5395c012 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -315,10 +315,10 @@ else:
     CTATGENOMEDIR = None
 if not rundedup:
     rule themall:
-        input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
+        input:  expand("FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv", combo=combo, file=samplecond(SAMPLES, config))
 else:
     rule themall:
-        input:  expand("FUSIONS/{combo}/{file}_{type}", combo=combo, file=samplecond(SAMPLES, config), type=['sorted', 'sorted_dedup'])
+        input:  expand("FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv", combo=combo, file=samplecond(SAMPLES, config))
 rule generate_ctat_lib:
     input:  fa = REFERENCE,
             anno = ANNOTATION
@@ -340,44 +340,44 @@ if not fastqmode:
     rule starfusion:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
                 lib = ctat_lib_input
-        output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction",
-                outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+        output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv",
+                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction"
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
         conda:  "<REPO>/envs/"+FENV+".yaml"
         container: "oras://docker.io/jfallmann/monsda:"+FENV+""
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; OUTDIR=$(dirname {output.preds}); if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; else mkdir -p $OUTDIR; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.preds} {output.abridged}"
 else:
     if paired == 'paired':
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                     r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
                     lib = ctat_lib_input
-            output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                    abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
             container: "oras://docker.io/jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
                     lib = ctat_lib_input
-            output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                    abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
             container: "oras://docker.io/jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index 9eeee414..602c7f3d 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -19,15 +19,15 @@ process starfusion{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("_fusions") > 0)      "FUSIONS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"        
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"
+        if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else      "FUSIONS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
     input:
     path fls
 
     output:
-    path "*_fusions", emit: fusions
+    path "${fn}_starfusion/*", emit: fusions
     path "log", emit: log
 
     script:
@@ -35,11 +35,11 @@ process starfusion{
     anno = fls[1]
     junction = fls[2]        
     fn = file(junction).getSimpleName()
-    of = fn+"_fusions"
+    od = fn+"_starfusion"
     ol = fn+".log"
     
     """
-    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir TMP --CPU ${task.cpus} $FUSPARAMS &>> log && cp TMP/star-fusion.fusion_predictions.tsv ${of} 2>> log; else echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; touch ${of}
+    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> log; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
     """
 }
 
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index a56a581b..4dfc03b1 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -16,10 +16,10 @@ else:
 
 if not rundedup:
     rule themall:
-        input:  expand("FUSIONS/{combo}/{file}_fusions", combo=combo, file=samplecond(SAMPLES, config))
+        input:  expand("FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv", combo=combo, file=samplecond(SAMPLES, config))
 else:
     rule themall:
-        input:  expand("FUSIONS/{combo}/{file}_{type}", combo=combo, file=samplecond(SAMPLES, config), type=['sorted', 'sorted_dedup'])
+        input:  expand("FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv", combo=combo, file=samplecond(SAMPLES, config))
 
 rule generate_ctat_lib:
     input:  fa = REFERENCE,
@@ -45,41 +45,41 @@ if not fastqmode:
     rule starfusion:
         input:  junction = expand("MAPPED/{scombo}/{{file}}.Chimeric.out.junction", scombo=scombo),
                 lib = ctat_lib_input
-        output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction",
-                outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+        output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv",
+                normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction"
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
         conda:  ""+FENV+".yaml"
         container: "oras://jfallmann/monsda:"+FENV+""
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
-        shell:  "set +o pipefail; if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; else mkdir -p {output.outdir}; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.fusions}"
+        shell:  "set +o pipefail; OUTDIR=$(dirname {output.preds}); if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; else mkdir -p $OUTDIR; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.preds} {output.abridged}"
 else:
     if paired == 'paired':
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                     r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
                     lib = ctat_lib_input
-            output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                    abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  ""+FENV+".yaml"
             container: "oras://jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"
     else:
         rule starfusion:
             input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
                     lib = ctat_lib_input
-            output: fusions = "FUSIONS/{combo}/{file}_fusions",
-                    outdir = temp(directory("FUSIONS/{combo}/{file}_tmp"))
+            output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
+                    abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  ""+FENV+".yaml"
             container: "oras://jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
-            shell:  "{params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir {output.outdir} --CPU {threads} {params.fpara} &> {log} && cp {output.outdir}/star-fusion.fusion_predictions.tsv {output.fusions} 2>> {log}; touch {output.fusions}"
+            shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"

From 0f37af3e58223cabd8f8a0be9e38098320bbe72e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 29 Jul 2026 14:02:33 +0200
Subject: [PATCH 18/80] added rustar as drop-in replacement for star with help
 from claude

---
 configs/template.json                         |   9 +
 containers/apptainer/rustar.def               |  31 +
 docs/source/workflows.rst                     |   2 +
 envs/rustar.yaml                              |  11 +
 tests/data/config_Test.json                   |   8 +
 ..._fastqc-bbduk-picard-rustar_subconfig.json |  87 ++
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf | 585 +++++++++++++
 ...stqc-cutadapt-picard-rustar_subconfig.json |  87 ++
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf | 585 +++++++++++++
 ...qc-trimgalore-picard-rustar_subconfig.json |  87 ++
 ...fastqc-trimgalore-picard-rustar_subflow.nf | 580 +++++++++++++
 tests/golden/config_Test/nf/_filelist.txt     |   6 +
 ..._fastqc-bbduk-picard-rustar_subconfig.json |  95 +++
 ...st_fastqc-bbduk-picard-rustar_subsnake.smk | 769 +++++++++++++++++
 ...stqc-cutadapt-picard-rustar_subconfig.json |  95 +++
 ...fastqc-cutadapt-picard-rustar_subsnake.smk | 769 +++++++++++++++++
 ...qc-trimgalore-picard-rustar_subconfig.json |  95 +++
 ...stqc-trimgalore-picard-rustar_subsnake.smk | 776 ++++++++++++++++++
 tests/golden/config_Test/smk/_filelist.txt    |   6 +
 workflows/rustar.nf                           | 164 ++++
 workflows/rustar.smk                          |  97 +++
 21 files changed, 4944 insertions(+)
 create mode 100644 containers/apptainer/rustar.def
 create mode 100644 envs/rustar.yaml
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subconfig.json
 create mode 100644 tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
 create mode 100644 workflows/rustar.nf
 create mode 100644 workflows/rustar.smk

diff --git a/configs/template.json b/configs/template.json
index a23f4e4d..1ed68f3d 100644
--- a/configs/template.json
+++ b/configs/template.json
@@ -157,6 +157,7 @@
     "MAPPING": { #options for mapping for each sample/condition
                  "TOOLS": {
                      "star": "STAR",
+                     "rustar": "rustar",
                      "segemehl3": "segemehl.x",
                      "segemehl": "segemehl.x",
                      "hisat2": "hisat2",
@@ -179,6 +180,14 @@
                                         "EXTENSION" : ""
                                     }
                              },
+                             "rustar":{
+                                 "OPTIONS":  # drop-in STAR replacement (rustar-aligner), same options as star
+                                    {
+                                        "INDEX" : "--sjdbGTFfeatureExon exon --sjdbGTFtagExonParentTranscript Parent --genomeSAindexNbases 13",  #indexing options
+                                        "MAP": "--sjdbGTFfeatureExon exon --sjdbGTFtagExonParentTranscript Parent --outSAMprimaryFlag AllBestScore --outSAMattributes NH HI NM MD AS nM jM jI XS",  #mapping options
+                                        "EXTENSION" : ""
+                                    }
+                             },
                              "segemehl3": {
                                 "OPTIONS":
                                 {
diff --git a/containers/apptainer/rustar.def b/containers/apptainer/rustar.def
new file mode 100644
index 00000000..1dc192de
--- /dev/null
+++ b/containers/apptainer/rustar.def
@@ -0,0 +1,31 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+   
+%files
+    /home/fall/MONSDA/envs/rustar.yaml /opt/envs/
+    ${HOME}/MONSDA/scripts /opt/MONSDA/
+
+%environment
+   
+%post
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/rustar.yaml
+    
+    ENV_NAME=rustar
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+   
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/rustar.yaml -p /opt/conda/envs/$ENV_NAME
+    conda activate $ENV_NAME
+   
+    # rustar-aligner is not distributed via conda/crates.io, so build it from source
+    # using the Rust toolchain provided by the conda environment.
+    cargo install --git https://github.com/scverse/rustar-aligner --locked --root /opt/conda/envs/$ENV_NAME
+    # MONSDA expects the mapper binary to be called "rustar"
+    ln -fs /opt/conda/envs/$ENV_NAME/bin/rustar-aligner /opt/conda/envs/$ENV_NAME/bin/rustar
+   
+    conda clean --all
+   
+%runscript
+    exec "$@"
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index 07f1fb85..345a02e3 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -149,6 +149,8 @@ Maps sequences to reference genomes or transcriptomes
   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
   | STAR         | Spliced Transcripts Alignment to a Reference                                                                               | star                 | STAR        | `star <https://github.com/alexdobin/STAR>`_                         | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+  | rustar       | Pure-Rust reimplementation of STAR, drop-in replacement with STAR-compatible CLI and index                                 | rustar               | rustar      | `rustar-aligner <https://github.com/scverse/rustar-aligner>`_       | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
+  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
   | STARsolo        | STARsolo: mapping, demultiplexing and quantification for single cell RNA-seq                                                                               | star                 | STAR        | `STARsolo <https://github.com/alexdobin/STAR/blob/master/docs/STARsolo.md>`_                         | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
   | Segemehl2|3  | Segemehl is a software to map short sequencer reads to reference genomes.                                                  | segemehl2/segemehl3  | segemehl.x  | `segemehl <https://www.bioinf.uni-leipzig.de/Software/segemehl/>`_  | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
diff --git a/envs/rustar.yaml b/envs/rustar.yaml
new file mode 100644
index 00000000..2004ea2a
--- /dev/null
+++ b/envs/rustar.yaml
@@ -0,0 +1,11 @@
+name: rustar
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - samtools =1.21
+  - rust >=1.85
+  - git
+  - openssl
+  - pkg-config
diff --git a/tests/data/config_Test.json b/tests/data/config_Test.json
index 98eb5124..e15f6af3 100644
--- a/tests/data/config_Test.json
+++ b/tests/data/config_Test.json
@@ -81,6 +81,7 @@
     "MAPPING": {
         "TOOLS": {
             "star": "STAR",
+            "rustar": "rustar",
             "bwa": "bwa mem"
         },
         "Test": {
@@ -91,6 +92,13 @@
                     "EXTENSION": ""
                 }
             },
+            "rustar": {
+                "OPTIONS": {
+                    "INDEX": "",
+                    "MAP": "--outSAMprimaryFlag AllBestScore",
+                    "EXTENSION": ""
+                }
+            },
             "bwa": {
                 "OPTIONS": {
                     "INDEX": "",
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subconfig.json
new file mode 100644
index 00000000..66288064
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
new file mode 100644
index 00000000..d6661001
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -0,0 +1,585 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
+}
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+}()
+
+process qc_raw{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch())
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+process trim{
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"        
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        ${params.gTRIMBIN} ${params.gTRIMPARAMS} t=${task.cpus} in=$r1 out=$o &> $r 
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( params.gPREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
+        } else{
+            trim(samples_ch().collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+process dedup_bam{
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process rustar_idx{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "${params.gMAPUIDXNAME}", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir RUSTARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} rustar.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf RUSTARTMP
+    """
+}
+process rustar_mapping{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (params.gPAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (params.gSTRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (params.gSTRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(params.gMAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(params.gMAPUIDX)
+        rustar_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
+        rustar_idx(genomefile, annofile)
+        rustar_mapping(rustar_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = rustar_mapping.out.maps
+    logs = rustar_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (params.gCOMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+process mqc{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy())
+    TRIMMING(dummy())
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subconfig.json
new file mode 100644
index 00000000..19b174eb
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
new file mode 100644
index 00000000..2eaf8640
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -0,0 +1,585 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
+}
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+}()
+
+process qc_raw{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch())
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+process trim{
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o -p $p $r1 $r2 &> $r
+        """
+    }
+    else{
+        o = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
+        r = file(reads).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
+        """
+        ${params.gTRIMBIN} --cores ${task.cpus} ${params.gTRIMPARAMS} -o $o $reads &> $r
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( params.gPREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
+        } else{
+            trim(samples_ch().collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+process dedup_bam{
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process rustar_idx{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "${params.gMAPUIDXNAME}", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir RUSTARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} rustar.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf RUSTARTMP
+    """
+}
+process rustar_mapping{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (params.gPAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (params.gSTRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (params.gSTRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(params.gMAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(params.gMAPUIDX)
+        rustar_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
+        rustar_idx(genomefile, annofile)
+        rustar_mapping(rustar_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = rustar_mapping.out.maps
+    logs = rustar_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (params.gCOMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+process mqc{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy())
+    TRIMMING(dummy())
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subconfig.json b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subconfig.json
new file mode 100644
index 00000000..d8e33f5f
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subconfig.json
@@ -0,0 +1,87 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "OPTIONS": {
+        "DEDUP": ""
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "OPTIONS": {
+        "EXTENSION": "",
+        "INDEX": "",
+        "MAP": "--outSAMprimaryFlag AllBestScore"
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "OPTIONS": {
+        "MULTI": "",
+        "QC": ""
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "OPTIONS": {
+        "TRIM": "--length 8"
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
new file mode 100644
index 00000000..7581b164
--- /dev/null
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -0,0 +1,580 @@
+#!/usr/bin/env nextflow
+nextflow.enable.dsl=2
+def get_always(parameter){
+    return params.containsKey(parameter) ? params[parameter] : null
+}
+params.gREFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
+params.gREFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
+params.gBINS = get_always('BINS')
+params.gTHREADS = get_always('MAXTHREAD')
+params.gPAIRED = get_always('PAIRED') ?: null
+params.gRUNDEDUP = get_always('RUNDEDUP') ?: null
+params.gPREDEDUP = get_always('PREDEDUP') ?: null
+params.gSTRANDED = get_always('STRANDED') ?: null
+params.gIP = get_always('IP') ?: null
+params.gCONDITION = get_always('CONDITION') ?: null
+params.gCOMBO = get_always('COMBO') ?: ''
+params.gSCOMBO = get_always('SCOMBO') ?: ''
+params.gSAMPLES = get_always('SAMPLES').split(',') ?: null
+params.gLONGSAMPLES = get_always('LONGSAMPLES').split(',') ?: null
+params.gSHORTSAMPLES = get_always('SHORTSAMPLES').split(',') ?: null
+params.gSETS = get_always('SETS') ?: null
+def dummy(){
+    def dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
+    return dummy
+}
+def samples_ch(){
+    def samples_ch = Channel.fromPath(params.gRSAMPLES)
+    return samples_ch
+}
+params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
+params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
+params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gTRIMENV = get_always('TRIMMINGENV')
+params.gTRIMBIN = get_always('TRIMMINGBIN')
+params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
+params.gDEDUPENV = get_always('DEDUPENV')
+params.gDEDUPBIN = get_always('DEDUPBIN')
+params.gDEDUPPARAMS = get_always('picard_params_DEDUP') ?: ''
+params.gJAVAPARAMS = get_always('picard_params_JAVA') ?: ''
+params.gMAPENV = get_always('MAPPINGENV')
+params.gMAPBIN = get_always('MAPPINGBIN')
+params.gMAPIDX = get_always('MAPPINGIDX')
+params.gMAPUIDX = { def MAPUIDX = get_always('MAPPINGUIDX'); MAPUIDX = MAPUIDX.replace('.idx',''); return MAPUIDX }()
+params.gMAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+params.gMAPREF = get_always('MAPPINGREF')
+params.gMAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+params.gMAPANNO = get_always('MAPPINGANNO')
+params.gMAPPREFIX = get_always('MAPPINGPREFIX')
+params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
+params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gRSAMPLES = {
+if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+    }
+}else{
+    return params.gSAMPLES.collect{
+        element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+    }
+}
+}()
+
+process qc_raw{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_RAW{
+    take:
+    collection
+    main:
+    qc_raw(samples_ch())
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+process qc_trimmed{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_TRIMMING{
+    take: collection
+    main:
+    qc_trimmed(collection)
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+process qc_mapped{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} -f bam $map
+    """
+}
+workflow QC_MAPPING{
+    take: collection
+    main:
+    qc_mapped(collection)
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+process qc_dedup{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+    input:
+    path read
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+    script:
+    """
+    fastqc --quiet -t ${task.cpus} ${params.gQCPARAMS} --noextract -f fastq $read
+    """
+}
+workflow QC_DEDUP{
+    take: collection
+    main:
+    qc_dedup(collection)
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
+
+
+process trim{
+    conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    cpus 4
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
+        else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path reads
+    output:
+    path "*_trimmed.fastq.gz", emit: trim
+    path "*trimming_report.txt", emit: rep
+    script:
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[0]
+        r2 = reads[1]
+        """
+        ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+    else{
+        """
+        ${params.gTRIMBIN} --cores ${task.cpus} --gzip ${params.gTRIMPARAMS} $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        """
+    }
+}
+workflow TRIMMING{
+    take: 
+    collection    
+    main:
+    if ( params.gPREDEDUP == 'enabled' ){  
+        trim(collection)
+    }else {        
+        if (params.gPAIRED == 'paired'){
+            trim(samples_ch().collate(2))
+        } else{
+            trim(samples_ch().collate(1))
+        }
+    }
+    emit:
+    trimmed = trim.out.trim
+    report  = trim.out.rep
+}
+
+
+process dedup_bam{
+    conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else null
+    }
+    input:
+    path todedup
+    path bami
+    output:
+    path "*_dedup.bam", emit: bam
+    path "*_dedup.bam.bai", emit: bai
+    path "*_dedup.log", emit: logs
+    path "*_dedup_metrix.txt", emit: metrics
+    script:
+    bams = todedup[0]
+    bais = todedup[1]
+    outf = bams.getSimpleName()+"_dedup.bam"
+    outl = bams.getSimpleName()+"_dedup.log"
+    outm = bams.getSimpleName()+"_dedup_metrix.txt"
+    """
+    mkdir -p TMP && ${params.gDEDUPBIN} ${params.gJAVAPARAMS} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm ${params.gDEDUPPARAMS} &> $outl && samtools index $outf &>> $outl
+    """
+}
+workflow DEDUPBAM{
+    take:
+    map
+    mapi
+    mapu
+    mapui
+    main:   
+    dedup_bam(map.concat(mapu), mapi.concat(mapui))
+    emit:
+    dedup = dedup_bam.out.bam
+    dedupbai = dedup_bam.out.bai
+    deduplog = dedup_bam.out.logs
+}
+
+
+process collect_tomap{
+    input:
+    path check
+    output:
+    path "collect.txt", emit: done
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+process rustar_idx{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
+        else                                             "${params.gMAPUIDX}"
+    }
+    input:
+    path genome
+    path anno
+    output:
+    path "${params.gMAPUIDXNAME}", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir RUSTARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} rustar.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf RUSTARTMP
+    """
+}
+process rustar_mapping{
+    conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    label 'big_mem'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+        else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
+    }
+    input:
+    path reads
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (params.gPAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (params.gPAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (params.gSTRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (params.gSTRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+            """
+            ${params.gMAPBIN} ${params.gMAPPARAMS} $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+workflow MAPPING{
+    take: collection
+    main:
+    checkidx = file(params.gMAPUIDX)
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(params.gMAPUIDX)
+        rustar_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(params.gMAPREF)
+        annofile = Channel.fromPath(params.gMAPANNO)
+        rustar_idx(genomefile, annofile)
+        rustar_mapping(rustar_idx.out.idx.combine(collection))
+    }
+    emit:
+    mapped  = rustar_mapping.out.maps
+    logs = rustar_mapping.out.logs
+}
+
+
+process sortsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".sam.gz") > 0)     "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else null
+    }
+    input:
+    path map
+    output:
+    path "*_mapped_sorted.sam.gz", includeInputs:false, emit: sam
+    script:
+    fn = file(map[0]).getSimpleName()
+    sorted = fn+'_sorted.sam.gz'
+    def sortmem = Math.ceil(task.memory.giga as double) as int 
+    """
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    """
+}
+process sam2bam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+".bam"
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    """
+}
+process uniqsam{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*_unique.sam.gz", includeInputs:false, emit: sam
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    uniq = fn+'_unique.sam.gz'
+    if (params.gCOMBO.indexOf('-bwa') > 0){
+        bwa = 'bwa'
+    } else{
+        bwa = ''
+    }
+    """
+    ${params.gBINS}/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    """
+}
+process sam2bamuniq{
+    conda "<REPO>/envs/samtools.yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    cpus params.gTHREADS
+    memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
+        else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else null
+    }
+    input:
+    path sam
+    output:
+    path "*.bam", emit: bam
+    path "*.bai", emit: bai
+    path "*.log", emit: logs
+    script:
+    fn = file(sam[0]).getSimpleName()
+    bam = fn+'.bam'
+    """
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    """
+}
+workflow POSTMAPPING{
+    take: collection
+    main:
+    sortsam(collection)
+    sam2bam(sortsam.out.sam)
+    uniqsam(sortsam.out.sam)
+    sam2bamuniq(uniqsam.out.sam)
+    emit:
+    postmap  = sam2bam.out.bam
+    postbai  = sam2bam.out.bai
+    postmapuni = sam2bamuniq.out.bam
+    postunibai = sam2bamuniq.out.bai
+}
+
+
+process mqc{
+    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
+    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.html"
+        else "QC/Multi/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+    }
+    input:
+    path others, stageAs: 'mqc_input??/*'
+    output:
+    path "*.zip", emit: mqc
+    path "*.html", emit: html
+    script:
+    """
+    touch $others
+    OUT=\${PWD}
+    LIST=multiqc_inputs.txt
+    TMP_LIST=multiqc_inputs_unique.txt
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${params.gCOMBO}"
+    CONDITION_VAL="${params.gCONDITION}"
+    for i in $others; do
+        dirname "\$i" >> "\$LIST"
+    done
+    # If this is a rustqc combo and the corresponding fastqc combo exists,
+    # include the fastqc output directory in the same MultiQC report.
+    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
+        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+        if [[ -d "\$FQ_DIR" ]]; then
+            echo "\$FQ_DIR" >> "\$LIST"
+        fi
+    fi
+    sort -u "\$LIST" > "\$TMP_LIST"
+    export LC_ALL=en_US.utf8
+    export LC_ALL=C.UTF-8
+    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    """
+}
+workflow MULTIQC{
+    take:
+    otherqcs
+    main:
+    mqc(otherqcs.collect())
+    emit:
+    mqcres = mqc.out.mqc
+}
+
+
+
+
+workflow {
+    QC_RAW(dummy())
+    TRIMMING(dummy())
+    QC_TRIMMING(TRIMMING.out.trimmed)
+    MAPPING(TRIMMING.out.trimmed)
+    POSTMAPPING(MAPPING.out.mapped)
+    DEDUPBAM(POSTMAPPING.out.postmap, POSTMAPPING.out.postbai, POSTMAPPING.out.postmapuni, POSTMAPPING.out.postunibai)
+    QC_MAPPING(POSTMAPPING.out.postmap.concat(POSTMAPPING.out.postmapuni.concat(DEDUPBAM.out.dedup)))
+    MULTIQC(QC_RAW.out.qc.concat(QC_TRIMMING.out.qc.concat(QC_MAPPING.out.qc.concat(MAPPING.out.logs))).collect())
+}
+
diff --git a/tests/golden/config_Test/nf/_filelist.txt b/tests/golden/config_Test/nf/_filelist.txt
index ec57aa75..319891d9 100644
--- a/tests/golden/config_Test/nf/_filelist.txt
+++ b/tests/golden/config_Test/nf/_filelist.txt
@@ -1,12 +1,18 @@
 Test_fastqc-bbduk-picard-bwa_subconfig.json
 Test_fastqc-bbduk-picard-bwa_subflow.nf
+Test_fastqc-bbduk-picard-rustar_subconfig.json
+Test_fastqc-bbduk-picard-rustar_subflow.nf
 Test_fastqc-bbduk-picard-star_subconfig.json
 Test_fastqc-bbduk-picard-star_subflow.nf
 Test_fastqc-cutadapt-picard-bwa_subconfig.json
 Test_fastqc-cutadapt-picard-bwa_subflow.nf
+Test_fastqc-cutadapt-picard-rustar_subconfig.json
+Test_fastqc-cutadapt-picard-rustar_subflow.nf
 Test_fastqc-cutadapt-picard-star_subconfig.json
 Test_fastqc-cutadapt-picard-star_subflow.nf
 Test_fastqc-trimgalore-picard-bwa_subconfig.json
 Test_fastqc-trimgalore-picard-bwa_subflow.nf
+Test_fastqc-trimgalore-picard-rustar_subconfig.json
+Test_fastqc-trimgalore-picard-rustar_subflow.nf
 Test_fastqc-trimgalore-picard-star_subconfig.json
 Test_fastqc-trimgalore-picard-star_subflow.nf
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subconfig.json
new file mode 100644
index 00000000..dfa676e9
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "rustar": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "bbduk": "bbduk.sh"
+    },
+    "Test": {
+      "bbduk": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "bbduk.sh",
+  "TRIMMINGENV": "bbduk"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
new file mode 100644
index 00000000..141a2f5c
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -0,0 +1,769 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-bbduk-picard-rustar'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} t={threads} in1={input.r1} in2={input.r2} out1={output.o1} out2={output.o2} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1,
+                o2 = rules.bbduk_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule bbduk_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: MAXTHREAD
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
+                trim = TRIMBIN,
+        shell:  "{params.trim} t={threads} in={input.r1} out={output.o1} {params.tpara}"
+    rule bbduk_rename:
+        input:  o1 = rules.bbduk_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/rustar_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/rustar_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str(log))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subconfig.json
new file mode 100644
index 00000000..39492ffb
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "rustar": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "cutadapt": "cutadapt"
+    },
+    "Test": {
+      "cutadapt": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "cutadapt",
+  "TRIMMINGENV": "cutadapt"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
new file mode 100644
index 00000000..3c1d1131
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -0,0 +1,769 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-cutadapt-picard-rustar'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+if paired == 'paired':
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} -p {output.o2} {input.r1} {input.r2} &> {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1,
+                o2 = rules.cutadapt_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule cutadapt_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN,
+        shell:  "{params.trim} {params.tpara} --cores {threads} -o {output.o1} {input.r1} > {log}"
+    rule cutadapt_rename:
+        input:  o1 = rules.cutadapt_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/rustar_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/rustar_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str(log))
+
+
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subconfig.json b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subconfig.json
new file mode 100644
index 00000000..765513f3
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subconfig.json
@@ -0,0 +1,95 @@
+{
+  "BINS": "<REPO>/MONSDA/MONSDA/scripts",
+  "DEDUP": {
+    "TOOLS": {
+      "picard": "picard"
+    },
+    "Test": {
+      "picard": {
+        "OPTIONS": {
+          "DEDUP": ""
+        }
+      }
+    }
+  },
+  "DEDUPBIN": "picard",
+  "DEDUPENV": "picard",
+  "MAPPING": {
+    "TOOLS": {
+      "rustar": "rustar"
+    },
+    "Test": {
+      "rustar": {
+        "OPTIONS": {
+          "EXTENSION": "",
+          "INDEX": "",
+          "MAP": "--outSAMprimaryFlag AllBestScore"
+        }
+      }
+    }
+  },
+  "MAPPINGBIN": "rustar",
+  "MAPPINGENV": "rustar",
+  "MAXTHREADS": "4",
+  "PREQCBIN": "fastqc",
+  "PREQCENV": "fastqc",
+  "QC": {
+    "TOOLS": {
+      "fastqc": "fastqc"
+    },
+    "Test": {
+      "fastqc": {
+        "OPTIONS": {
+          "MULTI": "",
+          "QC": ""
+        }
+      }
+    }
+  },
+  "RUNDEDUP": "enabled",
+  "SAMPLES": [
+    "SRR6357070",
+    "SRR6357071",
+    "SRR6357072"
+  ],
+  "SETTINGS": {
+    "Test": {
+      "ANNOTATION": {
+        "GFF": "GENOME/genomic.gff.gz",
+        "GTF": "GENOME/genomic.gtf.gz"
+      },
+      "BATCHES": "",
+      "DECOY": "",
+      "GROUPS": [
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "INDEX": "",
+      "IP": "",
+      "PREFIX": "",
+      "REFERENCE": "GENOME/genome.fa.gz",
+      "SAMPLES": [
+        "SRR6357070",
+        "SRR6357071",
+        "SRR6357072"
+      ],
+      "SEQUENCING": "paired",
+      "TYPES": ""
+    }
+  },
+  "TRIMMING": {
+    "TOOLS": {
+      "trimgalore": "trim_galore"
+    },
+    "Test": {
+      "trimgalore": {
+        "OPTIONS": {
+          "TRIM": "--length 8"
+        }
+      }
+    }
+  },
+  "TRIMMINGBIN": "trim_galore",
+  "TRIMMINGENV": "trimgalore"
+}
\ No newline at end of file
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
new file mode 100644
index 00000000..29087028
--- /dev/null
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -0,0 +1,776 @@
+import glob
+import os
+import sys
+import inspect
+import snakemake
+import json
+import shutil
+import logging
+import tempfile
+import traceback as tb
+from collections import defaultdict
+from itertools import combinations
+import re
+cmd_subfolder = [os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA/MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"../MONSDA"), os.path.join(os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile( inspect.currentframe() )) )),"MONSDA")]
+for x in cmd_subfolder:
+    if x not in sys.path:
+        sys.path.insert(0, x)
+from MONSDA.Logger import makelogdir, setup_logger
+from MONSDA.Params import checkpaired, checkstranded, check_IP, sampleslong, basecall_samples, download_samples, env_bin_from_config, tool_params, samplecond, conditiononly, comparable_as_string, get_cutoff_as_string, get_reps, get_diego_samples, get_diego_groups, get_pairing, set_pairing, get_samples_postprocess, fixRunParameters
+from MONSDA.Utils import get_dict_hash, sub_dict, makeoutdir, keysets_from_dict, dict_inst
+loglevel='INFO'
+try:
+    scriptname = os.path.basename(inspect.stack()[-1].filename).replace('.py','')
+    if any(x in scriptname for x in ['MONSDA','Configurator']):
+        log = logging.getLogger(scriptname)
+    else:
+        log = logging.getLogger('snakemake')
+        for handler in log.handlers[:]:
+            handler.close()
+            log.removeHandler(handler)
+    handler = logging.FileHandler('LOGS/MONSDA.log', mode='a')
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M'))
+    log.addHandler(handler)
+    lvl = loglevel
+    log.setLevel(lvl)
+except Exception as err:
+    log = setup_logger(name='MONSDA.header', log_file='LOGS/MONSDA.log', logformat='%(asctime)s %(levelname)-8s %(name)-12s %(message)s', datefmt='%m-%d %H:%M', level=loglevel, filemode='a')
+    #log = setup_logger(name=scriptname, log_file='stderr', logformat='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', level=loglevel)
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    tbe = tb.TracebackException(
+        exc_type, exc_value, exc_tb,
+    )
+    log.error(''.join(tbe.format()))
+logid = 'header.smk: '
+#Make sure we have a TMP directory
+makeoutdir("TMP")
+# Parse SUBCONFIG
+try:
+    installpath = os.path.dirname(__file__).replace(
+        os.sep.join(["lib", "python3.9", "site-packages", "MONSDA"]), "share"
+    )
+except:
+    installpath = os.path.cwd()
+BINS = config.get("BINS")
+MAXTHREAD = int(config["MAXTHREADS"])
+# set maximum available memory for sorting
+def get_sortmem(w, resources):
+    # Otherwise, try mem of form 8G / 8GB, again skipping `<TBD>`
+    if hasattr(resources, "mem"):
+        mem_val = str(resources.mem)
+        if mem_val != "<TBD>":
+            mem_str = re.sub(r"GB?$", "", mem_val, flags=re.IGNORECASE).strip()
+            return max(int(mem_str) -2, 4)  # reserve 2GB for other processes, min 4GB
+    # Convert mem_mb if present and not `<TBD>`
+    if hasattr(resources, "mem_mb"):
+        mem_val = str(resources.mem_mb)
+        if mem_val != "<TBD>":
+            mem_mb = int(mem_val)
+            # round up to full GB
+            return max(int((mem_mb + 1023) / 1024) - 2, 4)  # reserve 2GB for other processes, min 4GB
+    # Fallback if everything is `<TBD>` or missing
+    # pick something conservative but nonzero
+    return 4  # 4 GB
+if not config.get('FETCH', False) and not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in sampleslong(config)]  
+elif not config.get("BASECALL", False):
+    SAMPLES = [os.path.join(x) for x in download_samples(config)] 
+else:
+    SAMPLES = [os.path.join(x) for x in basecall_samples(config)]
+if len(SAMPLES) < 1:
+    log.error(logid+'No samples found, please check config file')
+    sys.exit(logid+'ERROR: No samples found, please check config file')
+SETUP = keysets_from_dict(config['SETTINGS'], 'SAMPLES')[0]
+SETS = os.sep.join(SETUP)
+SETTINGS = sub_dict(config['SETTINGS'], SETUP)
+# Parse SETTINGS
+SEQUENCING = SETTINGS.get('SEQUENCING')
+REFERENCE = SETTINGS.get('REFERENCE')
+REFDIR = str(os.path.dirname(REFERENCE))
+INDEX = SETTINGS.get('INDEX')
+INDEX2 = SETTINGS.get('INDEX2')
+PREFIX = SETTINGS.get('PREFIX')
+ANNO = SETTINGS.get('ANNOTATION')
+DECOY = SETTINGS.get("DECOY")
+IP = SETTINGS.get('IP')
+rundedup = True if (config.get('RUNDEDUP')) == 'enabled' else False
+prededup = True if (config.get('PREDEDUP')) == 'enabled' else False
+ANNOTATION = False  # by default no annotation is set for every workflow step
+if rundedup:
+    if prededup:
+        log.info(logid+'(PRE)DEDUPLICATION ENABLED')
+    else:
+        log.info(logid+'DEDUPLICATION ENABLED')
+log.info(logid+'Working on SAMPLES: '+str(SAMPLES))
+paired = checkpaired([SAMPLES[0]], config)
+if paired == 'paired':
+    log.info('RUNNING SNAKEMAKE IN PAIRED READ MODE')
+elif paired == 'singlecell':
+    log.info('RUNNING SNAKEMAKE IN Singlecell MODE')
+stranded = checkstranded([SAMPLES[0]], config)
+if stranded != '':
+    log.info('RUNNING SNAKEMAKE WITH STRANDEDNESS '+str(stranded))
+# MAPPING Variables
+if 'MAPPING' in config:
+    MAPPERBIN, MAPPERENV = env_bin_from_config(config, 'MAPPING')
+    MAPCONF = sub_dict(config['MAPPING'], SETUP)
+    MAPPERENV = MAPPERENV.split('_')[0]
+    log.debug(logid+'MAPPINGCONFIG: '+str(SETUP)+'\t'+str(MAPCONF))
+    REF = MAPCONF[MAPPERENV].get("REFERENCE", MAPCONF.get("REFERENCE", config['MAPPING'].get("REFERENCE")))
+    MANNO = MAPCONF[MAPPERENV].get("ANNOTATION", MAPCONF.get("ANNOTATION", config['MAPPING'].get("ANNOTATION")))
+    MDECOY = MAPCONF[MAPPERENV].get("DECOY", MAPCONF.get("DECOY", config['MAPPING'].get("DECOY")))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if MANNO and MANNO != '':
+        ANNOTATION = MANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if MDECOY and not dict_inst(MDECOY):
+            DECOY = os.path.abspath(MDECOY)
+    elif dict_inst(DECOY) and DECOY.get(MAPPERENV):
+            DECOY = os.path.abspath(DECOY.get(MAPPERENV))
+    else:
+        DECOY = None
+    IDX = MAPCONF.get('INDEX', MAPCONF[MAPPERENV].get('INDEX'))
+    if IDX:
+        INDEX = IDX
+    if not INDEX:
+        INDEX = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx'
+    keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+    keydict["REF"] = REFERENCE
+    keydict["DECOY"] = DECOY
+    keydict["ENV"] = MAPPERENV
+    unik = get_dict_hash(keydict)
+    UIDX = expand("{refd}/INDICES/{mape}/{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+    INDICES = INDEX.split(',') if INDEX else list(UIDX)
+    INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+    IDX2 = MAPCONF.get('INDEX2', MAPCONF[MAPPERENV].get('INDEX2'))
+    if IDX2:
+        INDEX2 = IDX2
+    if not INDEX2 and ('segemehl' in MAPPERENV and 'bisulfite' in MAPPERENV):
+        if len(INDICES) > 1:
+            UIDX2 = expand("{refd}/INDICES/{mape}/{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            INDEX2 = str(os.path.abspath(INDICES[1])) if str(os.path.abspath(INDICES[1])) not in UIDX2 else str(os.path.abspath(INDICES[1]))+'_idx2'
+        else:
+            INDEX2 = str.join(os.sep, [REFDIR, 'INDICES', MAPPERENV])+'.idx2'
+    else:
+        INDEX2 = None
+        UIDX2 = None
+    MAPOPT = MAPCONF.get(MAPPERENV).get('OPTIONS')
+    PRE = MAPCONF.get('PREFIX', MAPCONF.get('EXTENSION', MAPOPT.get('PREFIX', MAPOPT.get('EXTENSION'))))
+    if PRE and PRE is not None:
+        PREFIX = PRE
+    if not PREFIX or PREFIX is None:
+        PREFIX = MAPPERENV
+# Peak Calling Variables
+if 'PEAKS' in config:
+    PEAKCONF = sub_dict(config['PEAKS'], SETUP)
+    PEAKBIN, PEAKENV = env_bin_from_config(config, 'PEAKS')
+    REF = PEAKCONF.get('REFERENCE', PEAKCONF[PEAKENV].get('REFERENCE', config['PEAKS'].get('REFERENCE')))
+    ANNOPEAK = PEAKCONF.get('ANNOTATION', PEAKCONF[PEAKENV].get('ANNOTATION', config['PEAKS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    if ANNOPEAK and ANNOPEAK != '':
+        ANNOTATION = ANNOPEAK
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+    if not IP:
+        IP = check_IP(SAMPLES, config)
+    log.info(logid+'Running Peak finding for '+IP+' protocol')
+# TRACKS/COUNTING Variables
+for x in ['TRACKS', 'COUNTING']:
+    if x in config:
+        XBIN, XENV = env_bin_from_config(config, x)
+        XCONF = sub_dict(config[x], SETUP)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get('REFERENCE', XCONF.get('REFERENCE', config[x].get('REFERENCE')))
+        XANNO = XCONF[XENV].get('ANNOTATION', XCONF.get('ANNOTATION', config[x].get('ANNOTATION')))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if XENV in ["salmon", "kallisto"]:
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe=XENV, unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# DE/DEU/DAS/DTU Variables
+for x in ['DE', 'DEU', 'DAS', 'DTU']:
+    if x in config:
+        XCONF = sub_dict(config[x], SETUP)
+        XBIN, XENV = env_bin_from_config(config, x)
+        XENV = XENV.split('_')[0]
+        log.debug(logid+'XCONFIG: '+str(SETUP)+'\t'+str(XCONF))
+        REF = XCONF[XENV].get("REFERENCE", XCONF.get("REFERENCE", config[x].get("REFERENCE")))
+        XANNO = XCONF[XENV].get("ANNOTATION", XCONF.get("ANNOTATION", config[x].get("ANNOTATION")))
+        XDECOY = XCONF[XENV].get("DECOY", XCONF.get("DECOY", config[x].get("DECOY")))
+        if XANNO and XANNO != '':
+            ANNOTATION = XANNO            
+        else:
+            ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+        if XDECOY and not dict_inst(XDECOY):
+            DECOY = XDECOY
+        elif dict_inst(DECOY) and DECOY.get(XENV):
+            DECOY = DECOY.get(XENV)
+        else:
+            DECOY = None
+        if REF:
+            REFERENCE = REF
+            REFDIR = str(os.path.dirname(REFERENCE))
+        if x == 'DTU':
+            IDX = XCONF.get('INDEX')
+            if IDX:
+                INDEX = IDX
+            if not INDEX:
+                INDEX = str.join(os.sep, [REFDIR, 'INDICES', XENV])+'.idx'
+                keydict = sub_dict(tool_params(SAMPLES[0], None, config, x, XENV)['OPTIONS'], ['INDEX'])
+                keydict["REF"] = REFERENCE
+                keydict["DECOY"] = DECOY
+                keydict["ENV"] = XENV
+                unik = get_dict_hash(keydict)
+                UIDX = expand("{refd}/INDICES/{xe}/{unikey}.idx", refd=REFDIR, xe="salmon", unikey=unik)
+            INDICES = INDEX.split(',') if INDEX else list(UIDX)
+            INDEX = str(os.path.abspath(INDICES[0])) if str(os.path.abspath(INDICES[0])) not in UIDX else str(os.path.abspath(INDICES[0]))+'_idx'
+# CIRCS Variables
+if 'CIRCS' in config:
+    CIRCCONF = sub_dict(config['CIRCS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'CIRCS')
+    log.debug(logid+'CIRCCONFIG: '+str(SETUP)+'\t'+str(CIRCCONF))
+    REF = CIRCCONF.get('REFERENCE', CIRCCONF[XENV].get('REFERENCE', config['CIRCS'].get('REFERENCE')))
+    XANNO = CIRCCONF.get('ANNOTATION', CIRCCONF[XENV].get('ANNOTATION', config['CIRCS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    CANNO = CIRCCONF.get('ANNOTATION')
+    if CANNO and CANNO != '':
+        ANNOTATION = CANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+# FUSIONS Variables
+if 'FUSIONS' in config:
+    FUSCONF = sub_dict(config['FUSIONS'], SETUP)
+    XBIN, XENV = env_bin_from_config(config, 'FUSIONS')
+    log.debug(logid+'FUSCONFIG: '+str(SETUP)+'\t'+str(FUSCONF))
+    REF = FUSCONF.get('REFERENCE', FUSCONF[XENV].get('REFERENCE', config['FUSIONS'].get('REFERENCE')))
+    XANNO = FUSCONF.get('ANNOTATION', FUSCONF[XENV].get('ANNOTATION', config['FUSIONS'].get('ANNOTATION')))
+    if REF:
+        REFERENCE = REF
+        REFDIR = str(os.path.dirname(REFERENCE))
+    FANNO = FUSCONF.get('ANNOTATION')
+    if FANNO and FANNO != '':
+        ANNOTATION = FANNO
+    else:
+        ANNOTATION = ANNO.get('GTF') if 'GTF' in ANNO and ANNO.get('GTF') != '' else ANNO.get('GFF')  # by default GTF format will be used
+combo = ''
+if ANNOTATION:
+    log.info(logid+f'Using COMBO: {combo}, REF: {REFERENCE}, ANNO: {ANNOTATION}, DECOY: {DECOY}, INDEX: {INDEX}, INDEX2: {INDEX2}, PREFIX: {PREFIX}, IP: {IP}, SETUP: {SETUP}, SEQUENCING: {SEQUENCING}, STRANDED: {stranded}, PAIRED: {paired}, RUNDEDUP: {rundedup}, PREDEDUP: {prededup}, SAMPLES: {SAMPLES}, BINS: {BINS}, MAXTHREAD: {MAXTHREAD}')
+####HEADER ENDS HERE####
+
+combo = 'fastqc-trimgalore-picard-rustar'
+
+wildcard_constraints:
+    combo = combo,
+    rawfile = '|'.join(list(SAMPLES)),
+    file = '|'.join(list(samplecond(SAMPLES, config))),
+    read = "R1|R2"
+
+
+rule themall:
+	input:	expand("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", combo=combo, file=samplecond(SAMPLES, config), type=["sorted", "sorted_unique"]),
+		expand("QC/Multi/{combo}/{condition}/multiqc_report.html", condition=str.join(os.sep, conditiononly(SAMPLES[0], config)), combo=combo)
+
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda: "<REPO>/envs/"+QCENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}"
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda: "<REPO>/envs/"+QCENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
+
+
+TRIMBIN, TRIMENV = env_bin_from_config(config,'TRIMMING')
+#outdir = 'TRIMMED_FASTQ'
+#wildcard_constraints:
+#    file = '|'.join(list(samplecond(SAMPLES, config))),
+#    read = "R1|R2"
+#    outdir = outdir
+#rule trimthemall:
+#    input: expand("{outdir}{file}_{read}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config), read=["R1","R2"]) if paired == \'paired\' else expand("{outdir}{file}_trimmed.fastq.gz", outdir=outdir, file=samplecond(SAMPLES, config))
+if paired == 'paired':
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
+                o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
+        log:   "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir=lambda wildcards, output:os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --paired --gzip {params.tpara} -o {params.odir} {input.r1} {input.r2} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1,
+                o2 = rules.trimgalore_trim.output.o2
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
+else:
+    rule trimgalore_trim:
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
+        log:    "LOGS/{combo}/{file}_trim.log"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
+        params: odir = lambda wildcards, output: os.path.dirname(output.o1),
+                tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
+                trim=TRIMBIN
+        shell:  "{params.trim} --cores {threads} --gzip {params.tpara} -o {params.odir} {input.r1} &> {log}"
+    rule trimgalore_rename:
+        input:  o1 = rules.trimgalore_trim.output.o1
+        output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        conda: "<REPO>/envs/"+TRIMENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        threads: 1
+        shell:  "mv {input.o1} {output.r1}"
+
+
+DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
+rule dedupbam:
+    input:  bam = "MAPPED/{combo}/{file}_mapped_{type}.bam"
+    output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
+            bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
+            met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
+            td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
+    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    conda: "<REPO>/envs/"+DEDUPENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    threads: 1
+    priority: 0               # This should be done after all mapping is done
+    params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
+            dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
+            dedup = DEDUPBIN
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/rustar_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/rustar_generate_index"
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
+            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+
+rule sortsam:
+    input:  mapps = rules.mapping.output.mapped
+    output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
+            tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
+            tmpfile = temp("TMP/{combo}/{file}")
+    log:    "LOGS/{combo}/{file}/sortsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 100
+    params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
+            sortmem = get_sortmem
+    shell: "set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}"
+rule sam2bam:
+    input:  sortedsam = rules.sortsam.output.sortedsam
+    output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
+            bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
+    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins = BINS
+    shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
+rule uniqsam:
+    input:  sortedsam = rules.sortsam.output.sortedsam,
+            bam = rules.sam2bam.output
+    output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
+    log: "LOGS/{combo}/{file}/uniqsam.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    params: bins=BINS
+    shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
+rule sam2bamuniq:
+    input: uniqsam = rules.uniqsam.output,
+           bam = rules.sam2bam.output
+    output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
+             uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    conda: "<REPO>/envs/samtools.yaml"
+    container: "oras://docker.io/jfallmann/monsda:samtools"
+    threads: MAXTHREAD
+    priority: 50
+    params: bins = BINS
+    shell: "zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}"
+
+
+if rundedup:
+    if paired == 'paired':
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),                    
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        if prededup:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+        else:
+            rule multiqc:
+                input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                        expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),                 
+                        expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_dedupmapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                conda: "<REPO>/envs/qc.yaml"
+                container: "oras://docker.io/jfallmann/monsda:qc"
+                threads: 1
+                params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+else:
+    if paired == 'paired':
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+    else:
+        rule multiqc:
+            input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+                    expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            conda: "<REPO>/envs/qc.yaml"
+            container: "oras://docker.io/jfallmann/monsda:qc"
+            threads: 1
+            params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+
+## Queue-agnostic fallback resources for all rules.
+## These defaults apply when a rule has no explicit resource set.
+## They keep local/non-Slurm runs from lacking baseline resource values.
+_fallback_rule_resources = {
+	"mem_mb": 20000,
+	"runtime": 480,
+	"nodes": 1,
+}
+_user_rule_defaults = config.get("DEFAULT_RULE_RESOURCES", {})
+if isinstance(_user_rule_defaults, dict):
+	_fallback_rule_resources.update(_user_rule_defaults)
+def _has_resource(rule_obj, resource_name):
+	try:
+		return resource_name in rule_obj.resources.keys()
+	except Exception:
+		return hasattr(rule_obj.resources, resource_name)
+def _set_resource(rule_obj, resource_name, value):
+	try:
+		rule_obj.resources[resource_name] = value
+	except Exception:
+		setattr(rule_obj.resources, resource_name, value)
+for _rule in workflow.rules:
+	for _res_name, _res_value in _fallback_rule_resources.items():
+		if not _has_resource(_rule, _res_name):
+			_set_resource(_rule, _res_name, _res_value)
+onsuccess:
+    print("Workflow finished, no error")
+onerror:
+	print("ERROR: "+str(log))
+
+
diff --git a/tests/golden/config_Test/smk/_filelist.txt b/tests/golden/config_Test/smk/_filelist.txt
index 2b49db00..b577d45b 100644
--- a/tests/golden/config_Test/smk/_filelist.txt
+++ b/tests/golden/config_Test/smk/_filelist.txt
@@ -1,12 +1,18 @@
 Test_fastqc-bbduk-picard-bwa_subconfig.json
 Test_fastqc-bbduk-picard-bwa_subsnake.smk
+Test_fastqc-bbduk-picard-rustar_subconfig.json
+Test_fastqc-bbduk-picard-rustar_subsnake.smk
 Test_fastqc-bbduk-picard-star_subconfig.json
 Test_fastqc-bbduk-picard-star_subsnake.smk
 Test_fastqc-cutadapt-picard-bwa_subconfig.json
 Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+Test_fastqc-cutadapt-picard-rustar_subconfig.json
+Test_fastqc-cutadapt-picard-rustar_subsnake.smk
 Test_fastqc-cutadapt-picard-star_subconfig.json
 Test_fastqc-cutadapt-picard-star_subsnake.smk
 Test_fastqc-trimgalore-picard-bwa_subconfig.json
 Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+Test_fastqc-trimgalore-picard-rustar_subconfig.json
+Test_fastqc-trimgalore-picard-rustar_subsnake.smk
 Test_fastqc-trimgalore-picard-star_subconfig.json
 Test_fastqc-trimgalore-picard-star_subsnake.smk
diff --git a/workflows/rustar.nf b/workflows/rustar.nf
new file mode 100644
index 00000000..11bd3d36
--- /dev/null
+++ b/workflows/rustar.nf
@@ -0,0 +1,164 @@
+MAPENV = get_always('MAPPINGENV')
+MAPBIN = get_always('MAPPINGBIN')
+MAPIDX = get_always('MAPPINGIDX')
+MAPUIDX = get_always('MAPPINGUIDX')
+MAPUIDXNAME = get_always('MAPPINGUIDXNAME')
+MAPREF = get_always('MAPPINGREF')
+MAPREFDIR = "${workflow.workDir}/../"+get_always('MAPPINGREFDIR')
+MAPANNO = get_always('MAPPINGANNO')
+MAPPREFIX = get_always('MAPPINGPREFIX')
+MAPUIDX = MAPUIDX.replace('.idx','')
+
+IDXPARAMS = get_always('rustar_params_INDEX') ?: ''
+MAPPARAMS = get_always('rustar_params_MAP') ?: ''
+
+//MAPPING PROCESSES
+
+process collect_tomap{
+    input:
+    path check
+
+    output:
+    path "collect.txt", emit: done
+
+    script:
+    """
+    echo "$check Collection successful!" > collect.txt
+    """
+}
+
+process rustar_idx{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
+    saveAs: {filename ->
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/rustar_index.log"
+        else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
+        else                                             "$MAPUIDX"
+    }
+
+    input:
+    path genome
+    path anno
+
+    output:
+    path "$MAPUIDXNAME", emit: idx
+    path "*.out", emit: idxlog
+    path "*.idx", emit: tmpidx
+
+    script:
+    gen =  genome.getName()
+    an  = anno.getName()
+
+    """
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir RUSTARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME rustar.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf RUSTARTMP
+    """
+}
+
+process rustar_mapping{
+    conda "$MAPENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MAPENV"
+    cpus THREADS
+	cache 'lenient'
+    label 'big_mem'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
+        //else if (filename.indexOf(".sam.gz") >0)     "MAPPED/${COMBO}/${CONDITION}/"+"${filename.replaceAll(/\Q.Aligned.out.sam.gz\E/,"")}_mapped.sam.gz"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+        else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
+    }
+
+    input:
+    path reads
+
+    output:
+    path "*_mapped.sam.gz", emit: maps
+    path "*.out", emit: outs
+    path "*.log", emit: logs
+    path "*Log*.out", emit: xtralogs
+    path "*.tab", emit: sjtab
+    path "*_unmapped.fastq.gz", includeInputs:false, emit: unmapped
+
+    script:
+    idx = reads[0]
+    idxdir = idx.toRealPath()
+    if (PAIRED == 'paired'){
+        r1 = reads[1]
+        r2 = reads[2]
+        a = "Trimming_report.txt"
+        fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+        of = fn+'.Aligned.out.sam'
+        gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+        """
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        """
+    }
+    else{
+        if (PAIRED != 'singlecell'){
+            read = reads[1]
+            fn = file(reads[1]).getSimpleName().replaceAll(/(_dedup)?_trimmed$/,"")+"."
+            of = fn+'Aligned.out.sam'
+            gf = of.replaceAll(/\Q.Aligned.out.sam\E/,"_mapped.sam.gz")
+            """
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            """
+        }
+        else{
+            if (STRANDED == 'fr'){
+                stranded = '--soloStrand Forward'
+            }else if (STRANDED == 'rf'){
+                stranded = '--soloStrand Reverse'
+            }else{
+                stranded = '--soloStrand Unstranded'
+            }
+            r1 = reads[1]
+            fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            if (MAPPARAMS.contains('--soloBarcodeMate 1')){
+                t = r2
+                r2 = r1
+                r1 = t
+            }
+            of = fn+'.Aligned.sortedByCoord.out.bam'
+            gf = of.replaceAll(/\Q.Aligned.sortedByCoord.out.bam\E/,"_mapped.sam.gz")
+
+            """
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            """
+        }
+    }
+}
+
+workflow MAPPING{
+    take: collection
+
+    main:
+    checkidx = file(MAPUIDX)
+    //collection.filter(~/.fastq.gz/)
+
+    if (checkidx.exists()){
+        idxfile = Channel.fromPath(MAPUIDX)
+        rustar_mapping(idxfile.combine(collection))
+    }
+    else{
+        genomefile = Channel.fromPath(MAPREF)
+        annofile = Channel.fromPath(MAPANNO)
+        rustar_idx(genomefile, annofile)
+        rustar_mapping(rustar_idx.out.idx.combine(collection))
+    }
+
+
+    emit:
+    mapped  = rustar_mapping.out.maps
+    logs = rustar_mapping.out.logs
+}
diff --git a/workflows/rustar.smk b/workflows/rustar.smk
new file mode 100644
index 00000000..6a094b5d
--- /dev/null
+++ b/workflows/rustar.smk
@@ -0,0 +1,97 @@
+MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
+keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
+keydict["REF"] = REFERENCE
+keydict["DECOY"] = DECOY
+keydict["ENV"] = MAPPERENV
+unik = get_dict_hash(keydict)
+
+rule generate_index:
+    input:  fa = REFERENCE
+    output: idx = directory(INDEX),
+            uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
+            idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
+            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    conda:  ""+MAPPERENV+".yaml"
+    container: "oras://jfallmann/monsda:"+MAPPERENV+""
+    threads: MAXTHREAD
+    params: mapp = MAPPERBIN,
+            ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
+            anno = ANNOTATION,                        
+            pref = PREFIX,
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/rustar_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/rustar_generate_index"
+
+if paired == 'paired':
+    rule mapping:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                uidx = rules.generate_index.output.uidx[0],
+                dummy = rules.generate_index.output.idxfile,
+                ref = REFERENCE
+        output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                log = "LOGS/{combo}/{file}/Log.out",
+                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+        log:    "LOGS/{combo}/{file}/mapping.log"
+        conda:  ""+MAPPERENV+".yaml"
+        container: "oras://jfallmann/monsda:"+MAPPERENV+""
+        threads: MAXTHREAD
+        params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                mapp = MAPPERBIN,
+                anno = ANNOTATION,
+                pref = PREFIX,
+                tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+        shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "
+
+else:
+    if paired != 'singlecell':
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda:  ""+MAPPERENV+".yaml"
+            container: "oras://jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}"
+    else:
+        rule mapping:
+            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
+                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+                    uidx = rules.generate_index.output.uidx[0],
+                    dummy = rules.generate_index.output.idxfile,
+                    ref = REFERENCE
+            output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
+                    unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
+                    unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
+                    log = "LOGS/{combo}/{file}/Log.out",
+                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
+            log:    "LOGS/{combo}/{file}/mapping.log"
+            conda:  ""+MAPPERENV+".yaml"
+            container: "oras://jfallmann/monsda:"+MAPPERENV+""
+            threads: MAXTHREAD
+            params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
+                    stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
+                    mapp = MAPPERBIN,
+                    anno = ANNOTATION,
+                    pref = PREFIX,
+                    r1 = lambda wildcards, input: input.r1 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r2.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq'),
+                    r2 = lambda wildcards, input: input.r2 if not '--soloBarcodeMate 1' in tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', "") else input.r1.replace('TRIMMED_','').replace('_trimmed.fastq', '.fastq').replace({combo}, ''),
+                    tocopy = lambda wildcards, output: os.path.dirname(output.mapped)
+            shell: "{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} "

From f7d5ceaa4264805f1c73ece7cc2207d84cd35310 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 11 Aug 2026 14:06:08 +0200
Subject: [PATCH 19/80] rammap env fix

---
 envs/rammap.yaml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/envs/rammap.yaml b/envs/rammap.yaml
index 79268aea..961a2337 100644
--- a/envs/rammap.yaml
+++ b/envs/rammap.yaml
@@ -5,7 +5,6 @@ channels:
   - nodefaults
 dependencies:
   - rust >=1.75
-  - cargo
   - git
   - zlib
   - pigz =2.6

From 39deeffa51c899b93e4cdb100a640f967358877f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 11 Aug 2026 14:13:31 +0200
Subject: [PATCH 20/80] added version constraint on containers, not all
 containers are built whenever a specific monsda version is released for
 exactly that version, keeps tooling clean and in direct line with conda envs

---
 .github/workflows/build-containers.yml        | 86 +++++++++++++++++++
 MONSDA/Containers.py                          | 13 +++
 MONSDA/RunMONSDA.py                           |  5 +-
 MONSDA/Workflows.py                           | 19 +++-
 docker/Dockerfile                             | 21 +++++
 scripts/container_matrix.py                   | 32 +++++++
 ...imgalore-picard-star_DTU_dexseq_subflow.nf | 14 +--
 ...mgalore-picard-star_DTU_drimseq_subflow.nf | 14 +--
 ...trimgalore-picard-star_DTU_spit_subflow.nf | 14 +--
 ...galore-picard-star_DTU_dexseq_subsnake.smk | 16 ++--
 ...alore-picard-star_DTU_drimseq_subsnake.smk | 18 ++--
 ...imgalore-picard-star_DTU_spit_subsnake.smk | 18 ++--
 ...-picard-star_FUSIONS_starfusion_subflow.nf |  2 +-
 ...icard-star_FUSIONS_starfusion_subsnake.smk |  8 +-
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 26 +++---
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf | 26 +++---
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 26 +++---
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 26 +++---
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf | 26 +++---
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 26 +++---
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 26 +++---
 ...fastqc-trimgalore-picard-rustar_subflow.nf | 26 +++---
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 26 +++---
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk | 68 +++++++--------
 ...st_fastqc-bbduk-picard-rustar_subsnake.smk | 58 ++++++-------
 ...Test_fastqc-bbduk-picard-star_subsnake.smk | 58 ++++++-------
 ...st_fastqc-cutadapt-picard-bwa_subsnake.smk | 68 +++++++--------
 ...fastqc-cutadapt-picard-rustar_subsnake.smk | 58 ++++++-------
 ...t_fastqc-cutadapt-picard-star_subsnake.smk | 58 ++++++-------
 ..._fastqc-trimgalore-picard-bwa_subsnake.smk | 68 +++++++--------
 ...stqc-trimgalore-picard-rustar_subsnake.smk | 58 ++++++-------
 ...fastqc-trimgalore-picard-star_subsnake.smk | 58 ++++++-------
 tests/test_Workflows.py                       | 76 ++++++++++++++--
 33 files changed, 686 insertions(+), 456 deletions(-)
 create mode 100644 .github/workflows/build-containers.yml
 create mode 100644 MONSDA/Containers.py
 create mode 100644 docker/Dockerfile
 create mode 100644 scripts/container_matrix.py

diff --git a/.github/workflows/build-containers.yml b/.github/workflows/build-containers.yml
new file mode 100644
index 00000000..a9452d17
--- /dev/null
+++ b/.github/workflows/build-containers.yml
@@ -0,0 +1,86 @@
+name: Build MONSDA containers
+
+on:
+  pull_request_target:
+    types: [closed]
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+concurrency:
+  group: containers-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  prepare:
+    if: github.event_name != 'pull_request_target' || github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.matrix.outputs.matrix }}
+      version: ${{ steps.version.outputs.version }}
+      revision: ${{ steps.revision.outputs.revision }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.merge_commit_sha || github.event_name == 'release' && github.event.release.tag_name || github.sha }}
+      - id: matrix
+        run: echo "matrix=$(python scripts/container_matrix.py)" >> "$GITHUB_OUTPUT"
+      - id: version
+        run: python scripts/container_matrix.py --version >> "$GITHUB_OUTPUT"
+      - id: revision
+        run: echo "revision=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
+  build:
+    needs: prepare
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      max-parallel: 8
+      matrix: ${{ fromJSON(needs.prepare.outputs.matrix) }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.prepare.outputs.revision }}
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          push: true
+          build-args: |
+            ENVIRONMENT=${{ matrix.environment }}
+            MONSDA_VERSION=${{ needs.prepare.outputs.version }}
+            VCS_REF=${{ needs.prepare.outputs.revision }}
+          tags: ghcr.io/jfallmann/monsda:${{ matrix.environment }}-${{ needs.prepare.outputs.version }}
+          cache-from: type=gha,scope=${{ matrix.environment }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.environment }}
+
+  verify:
+    needs: [prepare, build]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.prepare.outputs.revision }}
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - env:
+          VERSION: ${{ needs.prepare.outputs.version }}
+        run: |
+          for environment in $(python scripts/container_matrix.py | python -c 'import json,sys; print(" ".join(json.load(sys.stdin)["environment"]))'); do
+            docker buildx imagetools inspect "ghcr.io/jfallmann/monsda:${environment}-${VERSION}" >/dev/null
+          done
diff --git a/MONSDA/Containers.py b/MONSDA/Containers.py
new file mode 100644
index 00000000..1f5b7d0d
--- /dev/null
+++ b/MONSDA/Containers.py
@@ -0,0 +1,13 @@
+import re
+
+from MONSDA import _version
+
+
+def normalize_container_version(version=None):
+    version = version or _version.get_versions()["version"]
+    version = re.sub(r"^v(?=\d)", "", version)
+    version = re.sub(r"(?:[.+-]dirty)$", "", version)
+    version = re.sub(r"[^A-Za-z0-9_.-]+", "-", version).strip(".-")
+    if not version:
+        raise ValueError("MONSDA version cannot be converted to an OCI tag")
+    return version
diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index bbbf838d..aa9ed908 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -141,10 +141,9 @@ def parseargs():
     parser.add_argument(
         "--oras-registry",
         type=str,
-        default="docker.io",
+        default="ghcr.io",
         metavar="HOST",
-        help="Container registry hostname for ORAS image pulls (default: docker.io). "
-             "Use e.g. ghcr.io for GitHub Container Registry.",
+        help="Container registry hostname for ORAS image pulls (default: ghcr.io).",
     )
     parser.add_argument(
         "--oras-namespace",
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 424d1549..b6b00616 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -37,6 +37,7 @@
 
 import MONSDA.Params as mp
 import MONSDA.Utils as mu
+from MONSDA.Containers import normalize_container_version
 from MONSDA.Utils import check_run as check_run
 from MONSDA.Utils import dump_if_different, write_if_different
 
@@ -56,11 +57,24 @@
 # Matches oras:// NOT already followed by a registry host (i.e. followed directly by a
 # Docker Hub namespace like "jfallmann/" without dots before the first slash)
 oraspath = re.compile(r'oras://(?![\w.-]+\.[\w.-]+/)')
-oras_registry = "docker.io"
+oras_registry = "ghcr.io"
 oras_default_namespace = "jfallmann/monsda"
 oras_namespace = oras_default_namespace
 
 
+def _version_oras_containers(content: str, version: str = None) -> str:
+    """Append the MONSDA version to each generated ORAS container reference."""
+    tag = normalize_container_version(version)
+    lines = list()
+    for line in content.splitlines(keepends=True):
+        body = line.rstrip("\r\n")
+        ending = line[len(body):]
+        if "container" in body and "oras://" in body and f'-{tag}"' not in body:
+            body += f'+"-{tag}"'
+        lines.append(body + ending)
+    return "".join(lines)
+
+
 def set_oras_registry(registry: str):
     """Set the ORAS registry used for container image URIs."""
     global oras_registry
@@ -74,7 +88,8 @@ def set_oras_namespace(namespace: str):
 
 
 def _rewrite_oras(content: str) -> str:
-    """Apply configured ORAS namespace and registry to oras:// URIs."""
+    """Version ORAS images and apply the configured namespace and registry."""
+    content = _version_oras_containers(content)
     if oras_namespace != oras_default_namespace:
         content = content.replace(
             "oras://" + oras_default_namespace, "oras://" + oras_namespace
diff --git a/docker/Dockerfile b/docker/Dockerfile
new file mode 100644
index 00000000..555ef591
--- /dev/null
+++ b/docker/Dockerfile
@@ -0,0 +1,21 @@
+FROM mambaorg/micromamba:2.0.5
+
+ARG ENVIRONMENT
+ARG MONSDA_VERSION
+ARG VCS_REF
+
+LABEL org.opencontainers.image.source="https://github.com/jfallmann/MONSDA"
+LABEL org.opencontainers.image.revision="${VCS_REF}"
+LABEL org.opencontainers.image.version="${MONSDA_VERSION}"
+LABEL org.opencontainers.image.title="MONSDA ${ENVIRONMENT} environment"
+
+COPY --chown=$MAMBA_USER:$MAMBA_USER envs/${ENVIRONMENT}.yaml /tmp/environment.yaml
+
+RUN micromamba create --yes --prefix /opt/conda/envs/monsda --file /tmp/environment.yaml \
+    && micromamba clean --all --yes
+
+ENV PATH="/opt/conda/envs/monsda/bin:${PATH}"
+ENV MONSDA_VERSION="${MONSDA_VERSION}"
+
+ENTRYPOINT ["/usr/local/bin/_entrypoint.sh"]
+CMD ["/bin/bash"]
diff --git a/scripts/container_matrix.py b/scripts/container_matrix.py
new file mode 100644
index 00000000..5b311897
--- /dev/null
+++ b/scripts/container_matrix.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from MONSDA.Containers import normalize_container_version  # noqa: E402
+
+
+def environment_names(root):
+    names = sorted(path.stem for path in (root / "envs").glob("*.yaml"))
+    if not names:
+        raise RuntimeError("No environment definitions found")
+    return names
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--version", action="store_true")
+    args = parser.parse_args()
+    if args.version:
+        print(f"version={normalize_container_version()}")
+    else:
+        print(json.dumps({"environment": environment_names(args.root)}))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
index facd7d71..e23a77a2 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -117,7 +117,7 @@ process salmon_quant{
 }
 process create_summary_snippet{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -138,7 +138,7 @@ process create_summary_snippet{
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
-    container "oras://docker.io/jfallmann/monsda:terminus"
+    container "oras://ghcr.io/jfallmann/monsda:terminus"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -159,7 +159,7 @@ process terminus_collapse{
 }
 process salmon_idx{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -187,7 +187,7 @@ process salmon_idx{
 }
 process prepare_dtu_annotation{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -207,7 +207,7 @@ process prepare_dtu_annotation{
 }
 process run_dexseq{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -239,7 +239,7 @@ process run_dexseq{
 }
 process collect_dexseq{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     input:
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
index 242c43fc..26b82d59 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -117,7 +117,7 @@ process salmon_quant{
 }
 process create_summary_snippet{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -138,7 +138,7 @@ process create_summary_snippet{
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
-    container "oras://docker.io/jfallmann/monsda:terminus"
+    container "oras://ghcr.io/jfallmann/monsda:terminus"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -159,7 +159,7 @@ process terminus_collapse{
 }
 process salmon_idx{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -187,7 +187,7 @@ process salmon_idx{
 }
 process prepare_dtu_annotation{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -207,7 +207,7 @@ process prepare_dtu_annotation{
 }
 process run_drimseq{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -240,7 +240,7 @@ process run_drimseq{
 }
 process collect_drimseq{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     input:
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
index 36f794d3..ff4c6f10 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -117,7 +117,7 @@ process salmon_quant{
 }
 process create_summary_snippet{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -138,7 +138,7 @@ process create_summary_snippet{
 }
 process terminus_collapse{
     conda "<REPO>/envs/terminus.yaml"
-    container "oras://docker.io/jfallmann/monsda:terminus"
+    container "oras://ghcr.io/jfallmann/monsda:terminus"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -159,7 +159,7 @@ process terminus_collapse{
 }
 process salmon_idx{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gCOUNTENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gCOUNTENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
@@ -187,7 +187,7 @@ process salmon_idx{
 }
 process prepare_dtu_annotation{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -207,7 +207,7 @@ process prepare_dtu_annotation{
 }
 process run_spit{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -238,7 +238,7 @@ process run_spit{
 }
 process collect_spit{
     conda "<REPO>/envs/${params.gDTUENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDTUENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDTUENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     input:
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
index cc787fc9..947ad664 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -329,7 +329,7 @@ rule salmon_index:
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
     log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = COUNTBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
@@ -363,7 +363,7 @@ if paired == 'paired':
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -379,7 +379,7 @@ else:
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -392,7 +392,7 @@ if runterminus:
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
         log:    "LOGS/{combo}/{file}/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: tpara = termpara,
                 outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
@@ -403,7 +403,7 @@ if runterminus:
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
         log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
         shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
@@ -415,7 +415,7 @@ rule create_annotation_table:
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
     params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
             bins = BINS
@@ -426,7 +426,7 @@ rule run_DTU:
             res = rules.themall.input.res
     log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1  # Due to BPPARAM errors, else int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins   = str.join(os.sep,[BINS, DTUBIN]),
             compare = comparison,
@@ -457,7 +457,7 @@ rule create_summary_snippet:
     output: rules.themall.input.Rmd
     log:    expand("LOGS/DTU/{combo}create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins = BINS,
             abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index e89d5750..ad06027f 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -339,7 +339,7 @@ rule salmon_index:
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
     log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = COUNTBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
@@ -373,7 +373,7 @@ if paired == 'paired':
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -389,7 +389,7 @@ else:
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -402,7 +402,7 @@ if runterminus:
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
         log:    "LOGS/{combo}/{file}/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: tpara = termpara,
                 outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
@@ -413,7 +413,7 @@ if runterminus:
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
         log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
         shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
@@ -425,7 +425,7 @@ rule create_annotation_table:
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
     params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
             bins = BINS
@@ -443,7 +443,7 @@ rule run_DTU:
             fig_files = rules.themall.input.fig_files
     log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins   = str.join(os.sep,[BINS, DTUBIN]),
             compare = comparison,
@@ -463,7 +463,7 @@ rule filter_significant_drimseq:
             sig_ut  = rules.themall.input.sig_ut
     log:    "LOGS/DTU/filter_drimseqDTU.log"
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
@@ -486,7 +486,7 @@ rule create_summary_snippet:
     output: rules.themall.input.Rmd
     log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins = BINS,
             abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index e8812b57..67bd4175 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -336,7 +336,7 @@ rule salmon_index:
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
     log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = COUNTBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('INDEX', ""),
@@ -370,7 +370,7 @@ if paired == 'paired':
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -386,7 +386,7 @@ else:
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
         log:    "LOGS/{combo}/{file}/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
         params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'DTU', DTUENV)['OPTIONS'].get('QUANT', ""),
                 mapp=COUNTBIN,
@@ -399,7 +399,7 @@ if runterminus:
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
         log:    "LOGS/{combo}/{file}/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: tpara = termpara,
                 outdir = lambda wildcards, output: os.path.dirname(os.path.dirname(str(output.grp)))
@@ -410,7 +410,7 @@ if runterminus:
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
         log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TERMINUSENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
         params: outdir = lambda wildcards, input: os.path.dirname(os.path.dirname(str(input.grps[0])))
         shell:  "terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}"
@@ -422,7 +422,7 @@ rule create_annotation_table:
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
     log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+COUNTENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
     params: dereps = lambda wildcards, input: get_reps(input.dir, config, 'DTU'),
             bins = BINS
@@ -437,7 +437,7 @@ rule run_DTU:
             fig_W   = rules.themall.input.fig_W
     log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins   = str.join(os.sep,[BINS, DTUBIN]),
             compare = comparison,
@@ -457,7 +457,7 @@ rule filter_significant_spit:
             sig_ut  = rules.themall.input.sig_ut
     log:    "LOGS/DTU/filter_spitDTU.log"
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
@@ -478,7 +478,7 @@ rule create_summary_snippet:
     output: rules.themall.input.Rmd
     log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DTUENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
     params: bins = BINS,
             abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index 32d64d1b..b4b5c483 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -49,7 +49,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process starfusion{
     conda "<REPO>/envs/${params.gFUSENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gFUSENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gFUSENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index 5395c012..c9cdade3 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -327,7 +327,7 @@ rule generate_ctat_lib:
             tmpanno = temp(expand("TMP/{fenv}/ctat_ref.gtf", fenv=FENV))
     log:    expand("LOGS/{sets}/{fenv}.ctat.log", sets=SETS, fenv=FENV)
     conda:  "<REPO>/envs/"+FENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
     threads: MAXTHREAD
     params: sf = FBIN,
             bpara = lambda wildcards: tool_params(SAMPLES[0], None, config, "FUSIONS", FENV)['OPTIONS'].get('BUILD', "")
@@ -345,7 +345,7 @@ if not fastqmode:
                 normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction"
         log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
         conda:  "<REPO>/envs/"+FENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
         threads: MAXTHREAD
         params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                 sf = FBIN
@@ -360,7 +360,7 @@ else:
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
@@ -373,7 +373,7 @@ else:
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
             log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+FENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
             threads: MAXTHREAD
             params: fpara = lambda wildcards: tool_params(wildcards.file, None, config, "FUSIONS", FENV)['OPTIONS'].get('FUSION', ""),
                     sf = FBIN
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index 7c21b10f..e73fc484 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -63,7 +63,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -91,7 +91,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -118,7 +118,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -145,7 +145,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -174,7 +174,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -228,7 +228,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -284,7 +284,7 @@ process collect_tomap{
 }
 process bwa_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -307,7 +307,7 @@ process bwa_idx{
 }
 process bwa_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -369,7 +369,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -392,7 +392,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -418,7 +418,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -447,7 +447,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -488,7 +488,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index d6661001..3c28a4c2 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -227,7 +227,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -283,7 +283,7 @@ process collect_tomap{
 }
 process rustar_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -309,7 +309,7 @@ process rustar_idx{
 }
 process rustar_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -400,7 +400,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -423,7 +423,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -449,7 +449,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -478,7 +478,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -519,7 +519,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 2f58f05e..6b04277b 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -227,7 +227,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -283,7 +283,7 @@ process collect_tomap{
 }
 process star_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -309,7 +309,7 @@ process star_idx{
 }
 process star_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -400,7 +400,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -423,7 +423,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -449,7 +449,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -478,7 +478,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -519,7 +519,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index 9d8bbbfb..16ec885b 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -63,7 +63,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -91,7 +91,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -118,7 +118,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -145,7 +145,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -174,7 +174,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -228,7 +228,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -284,7 +284,7 @@ process collect_tomap{
 }
 process bwa_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -307,7 +307,7 @@ process bwa_idx{
 }
 process bwa_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -369,7 +369,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -392,7 +392,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -418,7 +418,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -447,7 +447,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -488,7 +488,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index 2eaf8640..0b3ec7f9 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -227,7 +227,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -283,7 +283,7 @@ process collect_tomap{
 }
 process rustar_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -309,7 +309,7 @@ process rustar_idx{
 }
 process rustar_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -400,7 +400,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -423,7 +423,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -449,7 +449,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -478,7 +478,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -519,7 +519,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index 725a5549..e1730c77 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -227,7 +227,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -283,7 +283,7 @@ process collect_tomap{
 }
 process star_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -309,7 +309,7 @@ process star_idx{
 }
 process star_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -400,7 +400,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -423,7 +423,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -449,7 +449,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -478,7 +478,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -519,7 +519,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index e3ce88c7..debcf88b 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -63,7 +63,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -91,7 +91,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -118,7 +118,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -145,7 +145,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -174,7 +174,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -223,7 +223,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -279,7 +279,7 @@ process collect_tomap{
 }
 process bwa_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -302,7 +302,7 @@ process bwa_idx{
 }
 process bwa_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -364,7 +364,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -387,7 +387,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -413,7 +413,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -442,7 +442,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -483,7 +483,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index 7581b164..72617cd9 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -222,7 +222,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -278,7 +278,7 @@ process collect_tomap{
 }
 process rustar_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -304,7 +304,7 @@ process rustar_idx{
 }
 process rustar_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -395,7 +395,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -418,7 +418,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -444,7 +444,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -473,7 +473,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -514,7 +514,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index dc3f14f1..824d8c7e 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -62,7 +62,7 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -90,7 +90,7 @@ workflow QC_RAW{
 }
 process qc_trimmed{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -117,7 +117,7 @@ workflow QC_TRIMMING{
 }
 process qc_mapped{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -144,7 +144,7 @@ workflow QC_MAPPING{
 }
 process qc_dedup{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -173,7 +173,7 @@ workflow QC_DEDUP{
 
 process trim{
     conda "<REPO>/envs/${params.gTRIMENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gTRIMENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gTRIMENV}"+"-VERSION"
     cpus 4
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -222,7 +222,7 @@ workflow TRIMMING{
 
 process dedup_bam{
     conda "<REPO>/envs/${params.gDEDUPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gDEDUPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gDEDUPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -278,7 +278,7 @@ process collect_tomap{
 }
 process star_idx{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -304,7 +304,7 @@ process star_idx{
 }
 process star_mapping{
     conda "<REPO>/envs/${params.gMAPENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gMAPENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMAPENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     label 'big_mem'
@@ -395,7 +395,7 @@ workflow MAPPING{
 
 process sortsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -418,7 +418,7 @@ process sortsam{
 }
 process sam2bam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -444,7 +444,7 @@ process sam2bam{
 }
 process uniqsam{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -473,7 +473,7 @@ process uniqsam{
 }
 process sam2bamuniq{
     conda "<REPO>/envs/samtools.yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"samtools"
+    container "oras://ghcr.io/jfallmann/monsda:"+"samtools"+"-VERSION"
     cpus params.gTHREADS
     memory { 16.GB * (1 << ((task.attempt ?: 1) - 1)) }
 	cache 'lenient'
@@ -514,7 +514,7 @@ workflow POSTMAPPING{
 
 process mqc{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://docker.io/jfallmann/monsda:"+"${params.gQCENV}"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index 67865a8a..e334d81a 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.bbduk_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -483,7 +483,7 @@ rule generate_index:
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
     params: indexer = MAPPERBIN.split(' ')[0],
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
@@ -503,7 +503,7 @@ if bwaalg == 'mem':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
                     mapp = MAPPERBIN
@@ -518,7 +518,7 @@ if bwaalg == 'mem':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -537,7 +537,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -568,7 +568,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -597,7 +597,7 @@ elif bwaalg == 'samse':
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -615,7 +615,7 @@ elif bwaalg == 'sampe':
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -632,7 +632,7 @@ elif bwaalg == 'bwasw':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -645,7 +645,7 @@ elif bwaalg == 'bwasw':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -659,7 +659,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -671,7 +671,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -681,7 +681,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -692,7 +692,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -718,7 +718,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -738,7 +738,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -760,7 +760,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -780,7 +780,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -798,7 +798,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -815,7 +815,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
index 141a2f5c..3ff2e8f1 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.bbduk_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -486,7 +486,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -509,7 +509,7 @@ if paired == 'paired':
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -531,7 +531,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -554,7 +554,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -574,7 +574,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -586,7 +586,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -596,7 +596,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -607,7 +607,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -633,7 +633,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -653,7 +653,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -675,7 +675,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -695,7 +695,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -713,7 +713,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -730,7 +730,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index de008df0..fb34a212 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV).get('TRIM',""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.bbduk_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -486,7 +486,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -509,7 +509,7 @@ if paired == 'paired':
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -531,7 +531,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -554,7 +554,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -574,7 +574,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -586,7 +586,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -596,7 +596,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -607,7 +607,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -633,7 +633,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -653,7 +653,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -675,7 +675,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -695,7 +695,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -713,7 +713,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -730,7 +730,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index a1a7020c..b0e23530 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.cutadapt_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -483,7 +483,7 @@ rule generate_index:
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
     params: indexer = MAPPERBIN.split(' ')[0],
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
@@ -503,7 +503,7 @@ if bwaalg == 'mem':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
                     mapp = MAPPERBIN
@@ -518,7 +518,7 @@ if bwaalg == 'mem':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -537,7 +537,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -568,7 +568,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -597,7 +597,7 @@ elif bwaalg == 'samse':
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -615,7 +615,7 @@ elif bwaalg == 'sampe':
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -632,7 +632,7 @@ elif bwaalg == 'bwasw':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -645,7 +645,7 @@ elif bwaalg == 'bwasw':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -659,7 +659,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -671,7 +671,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -681,7 +681,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -692,7 +692,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -718,7 +718,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -738,7 +738,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -760,7 +760,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -780,7 +780,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -798,7 +798,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -815,7 +815,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
index 3c1d1131..d2ae0794 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.cutadapt_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -486,7 +486,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -509,7 +509,7 @@ if paired == 'paired':
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -531,7 +531,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -554,7 +554,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -574,7 +574,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -586,7 +586,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -596,7 +596,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -607,7 +607,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -633,7 +633,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -653,7 +653,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -675,7 +675,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -695,7 +695,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -713,7 +713,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -730,7 +730,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index cdebcde8..a26b5994 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -418,7 +418,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -430,7 +430,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -439,7 +439,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards:tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -449,7 +449,7 @@ else:
         input:  o1 = rules.cutadapt_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -463,7 +463,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -486,7 +486,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -509,7 +509,7 @@ if paired == 'paired':
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -531,7 +531,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -554,7 +554,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -574,7 +574,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -586,7 +586,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -596,7 +596,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -607,7 +607,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -633,7 +633,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -653,7 +653,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -675,7 +675,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -695,7 +695,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -713,7 +713,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -730,7 +730,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index 02c31bc5..abf5ebd1 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -425,7 +425,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:   "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -437,7 +437,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -446,7 +446,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -456,7 +456,7 @@ else:
         input:  o1 = rules.trimgalore_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -470,7 +470,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -490,7 +490,7 @@ rule generate_index:
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
     params: indexer = MAPPERBIN.split(' ')[0],
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
@@ -510,7 +510,7 @@ if bwaalg == 'mem':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get("MAP", ""),
                     mapp = MAPPERBIN
@@ -525,7 +525,7 @@ if bwaalg == 'mem':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -544,7 +544,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -575,7 +575,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN,
@@ -604,7 +604,7 @@ elif bwaalg == 'samse':
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -622,7 +622,7 @@ elif bwaalg == 'sampe':
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -639,7 +639,7 @@ elif bwaalg == 'bwasw':
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -652,7 +652,7 @@ elif bwaalg == 'bwasw':
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     mapp = MAPPERBIN
@@ -666,7 +666,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -678,7 +678,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -688,7 +688,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -699,7 +699,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -725,7 +725,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -745,7 +745,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -767,7 +767,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -787,7 +787,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -805,7 +805,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -822,7 +822,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
index 29087028..476addd5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -425,7 +425,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:   "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -437,7 +437,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -446,7 +446,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -456,7 +456,7 @@ else:
         input:  o1 = rules.trimgalore_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -470,7 +470,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -493,7 +493,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -516,7 +516,7 @@ if paired == 'paired':
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -538,7 +538,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -561,7 +561,7 @@ else:
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -581,7 +581,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -593,7 +593,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -603,7 +603,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -614,7 +614,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -640,7 +640,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -660,7 +660,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -682,7 +682,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -702,7 +702,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -720,7 +720,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -737,7 +737,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index ba75a675..4a1f5cad 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -312,7 +312,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
         log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -322,7 +322,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -332,7 +332,7 @@ if paired == 'paired':
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -343,7 +343,7 @@ else:
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -353,7 +353,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -363,7 +363,7 @@ else:
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
         log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
         priority: 10
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
@@ -373,7 +373,7 @@ rule qc_mapped:
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
     log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -383,7 +383,7 @@ rule qc_uniquemapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -393,7 +393,7 @@ rule qc_dedupmapped:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -403,7 +403,7 @@ rule qc_uniquededup:
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
     log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+QCENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
     shell: "OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}"
@@ -425,7 +425,7 @@ if paired == 'paired':
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
         log:   "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir=lambda wildcards, output:os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -437,7 +437,7 @@ if paired == 'paired':
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1} && mv {input.o2} {output.r2}"
 else:
@@ -446,7 +446,7 @@ else:
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
         log:    "LOGS/{combo}/{file}_trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
         params: odir = lambda wildcards, output: os.path.dirname(output.o1),
                 tpara = lambda wildcards: tool_params(wildcards.file, None, config, "TRIMMING", TRIMENV)['OPTIONS'].get('TRIM', ""),
@@ -456,7 +456,7 @@ else:
         input:  o1 = rules.trimgalore_trim.output.o1
         output: r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+TRIMENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: 1
         shell:  "mv {input.o1} {output.r1}"
 
@@ -470,7 +470,7 @@ rule dedupbam:
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
     log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+DEDUPENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
     priority: 0               # This should be done after all mapping is done
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
@@ -493,7 +493,7 @@ rule generate_index:
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-    container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+    container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
     params: mapp = MAPPERBIN,
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
@@ -516,7 +516,7 @@ if paired == 'paired':
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-        container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+        container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN,
@@ -538,7 +538,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),                    
                     mapp = MAPPERBIN,
@@ -561,7 +561,7 @@ else:
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
-            container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV+""
+            container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
             params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                     stranded = lambda x: '--soloStrand Forward' if stranded == 'fr' else '--soloStrand Reverse' if stranded == 'rf' else '--soloStrand Unstranded',
@@ -581,7 +581,7 @@ rule sortsam:
             tmpfile = temp("TMP/{combo}/{file}")
     log:    "LOGS/{combo}/{file}/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 100
     params: linkto = lambda wildcards, output: os.path.basename(output.sortedsam),
@@ -593,7 +593,7 @@ rule sam2bam:
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
     log:    "LOGS/{combo}/{file}/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins = BINS
     shell: "zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}"
@@ -603,7 +603,7 @@ rule uniqsam:
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
     log: "LOGS/{combo}/{file}/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     params: bins=BINS
     shell:  "{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}"
@@ -614,7 +614,7 @@ rule sam2bamuniq:
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
-    container: "oras://docker.io/jfallmann/monsda:samtools"
+    container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
     priority: 50
     params: bins = BINS
@@ -640,7 +640,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -660,7 +660,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -682,7 +682,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
@@ -702,7 +702,7 @@ if rundedup:
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
                 log:    "LOGS/{combo}/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
-                container: "oras://docker.io/jfallmann/monsda:qc"
+                container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
                 shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -720,7 +720,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
@@ -737,7 +737,7 @@ else:
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
             log:    "LOGS/{combo}/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
-            container: "oras://docker.io/jfallmann/monsda:qc"
+            container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
             shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index e3020b90..65230635 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -1,6 +1,7 @@
 import glob
 import json
 import os
+import re
 from pathlib import Path
 
 import pytest
@@ -11,6 +12,8 @@
 
 import MONSDA.Params as mp  # noqa: E402
 import MONSDA.Workflows as mw  # noqa: E402
+from MONSDA.Containers import normalize_container_version  # noqa: E402
+from scripts.container_matrix import environment_names  # noqa: E402
 
 REPO = Path(__file__).resolve().parents[1]
 DATA = REPO / "tests" / "data"
@@ -20,7 +23,7 @@
 
 
 @pytest.fixture(autouse=True)
-def _repo_template_paths():
+def _repo_template_paths(monkeypatch):
     """Point the generators at the in-repo workflow/env templates.
 
     In a dev checkout MONSDA is not pip-installed, so the module-level
@@ -30,6 +33,7 @@ def _repo_template_paths():
     old_wf, old_env = mw.workflowpath, mw.envpath
     mw.workflowpath = str(REPO / "workflows")
     mw.envpath = str(REPO / "envs") + os.sep
+    monkeypatch.setattr(mw, "normalize_container_version", lambda version=None: "VERSION")
     yield
     mw.workflowpath, mw.envpath = old_wf, old_env
 
@@ -394,17 +398,77 @@ def test_engines_expose_same_tools(both_engines):
             )
 
 
-def test_oras_namespace_and_registry_rewrite():
+@pytest.mark.parametrize(
+    "version,expected",
+    [
+        ("1.5.0", "1.5.0"),
+        ("1.5.0+12.gabcdef", "1.5.0-12.gabcdef"),
+        ("1.5.0+12.gabcdef.dirty", "1.5.0-12.gabcdef"),
+        ("v2.0.0/a", "2.0.0-a"),
+    ],
+)
+def test_normalize_container_version(version, expected):
+    assert normalize_container_version(version) == expected
+
+
+def test_normalize_container_version_rejects_empty_tag():
+    with pytest.raises(ValueError):
+        normalize_container_version("+++")
+
+
+def test_oras_namespace_registry_and_version_rewrite(monkeypatch):
     line = 'container: "oras://jfallmann/monsda:"+MAPPERENV'
+    monkeypatch.setattr(mw, "normalize_container_version", lambda version=None: "1.5.0")
     try:
         assert mw._rewrite_oras(line) == (
-            'container: "oras://docker.io/jfallmann/monsda:"+MAPPERENV'
+            'container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+"-1.5.0"'
         )
         mw.set_oras_namespace("myuser/myrepo")
-        mw.set_oras_registry("ghcr.io")
+        mw.set_oras_registry("registry.example.org")
         assert mw._rewrite_oras(line) == (
-            'container: "oras://ghcr.io/myuser/myrepo:"+MAPPERENV'
+            'container: "oras://registry.example.org/myuser/myrepo:"+MAPPERENV+"-1.5.0"'
         )
     finally:
         mw.set_oras_namespace(mw.oras_default_namespace)
-        mw.set_oras_registry("docker.io")
+        mw.set_oras_registry("ghcr.io")
+
+
+def test_oras_static_and_nextflow_containers_are_versioned(monkeypatch):
+    monkeypatch.setattr(mw, "normalize_container_version", lambda version=None: "1.5.0")
+    content = (
+        'container: "oras://jfallmann/monsda:perl"\n'
+        '    container "oras://jfallmann/monsda:"+"$QCENV"\n'
+    )
+    assert mw._rewrite_oras(content) == (
+        'container: "oras://ghcr.io/jfallmann/monsda:perl"+"-1.5.0"\n'
+        '    container "oras://ghcr.io/jfallmann/monsda:"+"$QCENV"+"-1.5.0"\n'
+    )
+
+
+def test_container_matrix_covers_every_environment():
+    expected = sorted(path.stem for path in (REPO / "envs").glob("*.yaml"))
+    assert environment_names(REPO) == expected
+
+
+def test_all_template_container_calls_are_versioned():
+    calls = list()
+    for pattern in ("*.smk", "*.nf"):
+        for path in (REPO / "workflows").glob(pattern):
+            calls.extend(
+                line for line in path.read_text().splitlines()
+                if "container" in line and "oras://" in line
+            )
+    assert calls
+    rewritten = [mw._rewrite_oras(line) for line in calls]
+    assert all(line.endswith('+"-VERSION"') for line in rewritten)
+
+
+def test_static_container_environments_exist():
+    static = set()
+    pattern = re.compile(r"oras://jfallmann/monsda:([A-Za-z0-9_.-]+)\"")
+    for suffix in ("*.smk", "*.nf"):
+        for path in (REPO / "workflows").glob(suffix):
+            static.update(pattern.findall(path.read_text()))
+    available = set(environment_names(REPO))
+    assert static
+    assert static <= available

From e9b601ab8564926640b066536f2282d87a1046a2 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 12 Aug 2026 16:09:38 +0200
Subject: [PATCH 21/80] yamls updated, new container build started

---
 envs/LoveSonesonPatro.yaml      | 143 ++-----------------
 envs/dexseq_DEU.yaml            |  42 +++---
 envs/dexseq_DTU.yaml            |  41 +++---
 envs/diego_DAS.yaml             |  22 +--
 envs/index.yaml                 |   6 +-
 envs/isoformswitchanalyzer.yaml | 137 ++----------------
 envs/monsda.yaml                |   8 +-
 envs/peaks.yaml                 | 236 +++-----------------------------
 envs/trimm.yaml                 |  16 +--
 9 files changed, 105 insertions(+), 546 deletions(-)

diff --git a/envs/LoveSonesonPatro.yaml b/envs/LoveSonesonPatro.yaml
index 2cac941a..4ad7bdda 100644
--- a/envs/LoveSonesonPatro.yaml
+++ b/envs/LoveSonesonPatro.yaml
@@ -4,132 +4,17 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - bioconductor-annotate =1.68.0 =r40_0
-  - bioconductor-annotationdbi =1.52.0 =r40_0
-  - bioconductor-biobase =2.50.0 =r40h037d062_0
-  - bioconductor-biocfilecache =1.14.0 =r40_0
-  - bioconductor-biocgenerics =0.36.0 =r40_0
-  - bioconductor-biocparallel =1.24.0 =r40h5f743cb_0
-  - bioconductor-biomart =2.46.0 =r40_0
-  - bioconductor-biostrings =2.58.0 =r40h037d062_0
-  - bioconductor-delayedarray =0.16.0 =r40h037d062_0
-  - bioconductor-deseq2 =1.39.0 =r40h5f743cb_0
-  - bioconductor-dexseq =1.36.0 =r40_0
-  - bioconductor-drimseq =1.18.0 =r40_0
-  - bioconductor-edger =4.4.0 =r40h5f743cb_0
-  - bioconductor-genefilter =1.72.0 =r40hc6cf775_0
-  - bioconductor-geneplotter =1.68.0 =r40_0
-  - bioconductor-genomeinfodb =1.26.0 =r40_0
-  - bioconductor-genomeinfodbdata =1.2.4 =r40_0
-  - bioconductor-genomicalignments =1.26.0 =r40h037d062_0
-  - bioconductor-genomicfeatures =1.42.0 =r40_0
-  - bioconductor-genomicranges =1.42.0 =r40h037d062_0
-  - bioconductor-iranges =2.24.0 =r40h037d062_0
-  - bioconductor-limma =3.46.0 =r40h037d062_0
-  - bioconductor-matrixgenerics =1.2.0 =r40_0
-  - bioconductor-rhtslib =1.22.0 =r40h037d062_0
-  - bioconductor-rsamtools =2.6.0 =r40h5f743cb_0
-  - bioconductor-rtracklayer =1.50.0 =r40h9bb0e53_1
-  - bioconductor-s4vectors =0.28.0 =r40h037d062_0
-  - bioconductor-stager =1.12.0 =r40_0
-  - bioconductor-summarizedexperiment =1.20.0 =r40_0
-  - bioconductor-tximport =1.18.0 =r40_0
-  - bioconductor-xvector =0.30.0 =r40h037d062_0
-  - bioconductor-zlibbioc =1.36.0 =r40h037d062_0
-  - r-askpass =1.1 =r40hcdcec82_2
-  - r-assertthat =0.2.1 =r40h6115d3f_2
-  - r-backports =1.2.0 =r40h9e2df91_0
-  - r-base =4.0.3 =hd272fe0_2
-  - r-bh =1.72.0_3 =r40h6115d3f_1
-  - r-bit =4.0.4 =r40hcdcec82_0
-  - r-bit64 =4.0.5 =r40hcdcec82_0
-  - r-bitops =1.0_6 =r40hcdcec82_1004
-  - r-blob =1.2.1 =r40h6115d3f_1
-  - r-brio =1.1.0 =r40h9e2df91_1
-  - r-callr =3.5.1 =r40h142f84f_0
-  - r-cli =2.1.0 =r40h142f84f_0
-  - r-colorspace =2.0_0 =r40h9e2df91_0
-  - r-crayon =1.3.4 =r40h6115d3f_1003
-  - r-curl =4.3 =r40hcdcec82_1
-  - r-dbi =1.1.0 =r40h6115d3f_1
-  - r-dbplyr =2.0.0 =r40hc72bb7e_0
-  - r-desc =1.2.0 =r40h6115d3f_1003
-  - r-diffobj =0.3.2 =r40h9e2df91_1
-  - r-digest =0.6.27 =r40h1b71b39_0
-  - r-dplyr =1.0.2 =r40h0357c0b_0
-  - r-ellipsis =0.3.1 =r40hcdcec82_0
-  - r-evaluate =0.14 =r40h6115d3f_2
-  - r-fansi =0.4.1 =r40hcdcec82_1
-  - r-farver =2.0.3 =r40h0357c0b_1
-  - r-formatr =1.7 =r40h6115d3f_2
-  - r-futile.logger =1.4.3 =r40h6115d3f_1003
-  - r-futile.options =1.0.1 =r40h6115d3f_1002
-  - r-generics =0.1.0 =r40hc72bb7e_0
-  - r-ggplot2 =3.3.2 =r40h6115d3f_0
-  - r-glue =1.4.2 =r40hcdcec82_0
-  - r-gtable =0.3.0 =r40h6115d3f_3
-  - r-hms =0.5.3 =r40h6115d3f_1
-  - r-httr =1.4.2 =r40h6115d3f_0
-  - r-hwriter =1.3.2 =r40h6115d3f_1003
-  - r-isoband =0.2.2 =r40h0357c0b_0
-  - r-jsonlite =1.7.1 =r40hcdcec82_0
-  - r-labeling =0.4.2 =r40h142f84f_0
-  - r-lambda.r =1.2.4 =r40h6115d3f_1
-  - r-lattice =0.20_41 =r40hcdcec82_2
-  - r-lifecycle =0.2.0 =r40h6115d3f_1
-  - r-locfit =1.5_9.4 =r40hcdcec82_1
-  - r-magrittr =2.0.1 =r40hc72bb7e_0
-  - r-mass =7.3_53 =r40hcdcec82_0
-  - r-matrix =1.2_18 =r40h7fa42b6_3
-  - r-matrixstats =0.57.0 =r40hcdcec82_0
-  - r-memoise =1.1.0 =r40h6115d3f_1004
-  - r-mgcv =1.8_33 =r40h7fa42b6_0
-  - r-mime =0.9 =r40hcdcec82_1
-  - r-munsell =0.5.0 =r40h6115d3f_1003
-  - r-nlme =3.1_150 =r40h31ca83e_0
-  - r-openssl =1.4.3 =r40he5c4762_0
-  - r-pillar =1.4.6 =r40h6115d3f_0
-  - r-pkgbuild =1.1.0 =r40h6115d3f_0
-  - r-pkgconfig =2.0.3 =r40h6115d3f_1
-  - r-pkgload =1.1.0 =r40h0357c0b_0
-  - r-plogr =0.2.0 =r40h6115d3f_1003
-  - r-plyr =1.8.6 =r40h0357c0b_1
-  - r-praise =1.0.0 =r40h6115d3f_1004
-  - r-prettyunits =1.1.1 =r40h6115d3f_1
-  - r-processx =3.4.4 =r40hcdcec82_0
-  - r-progress =1.2.2 =r40h6115d3f_2
-  - r-ps =1.4.0 =r40h0eb13af_0
-  - r-purrr =0.3.4 =r40hcdcec82_1
-  - r-r6 =2.5.0 =r40hc72bb7e_0
-  - r-rappdirs =0.3.1 =r40hcdcec82_1004
-  - r-rcolorbrewer =1.1_2 =r40h6115d3f_1003
-  - r-rcpp =1.0.5 =r40he524a50_0
-  - r-rcpparmadillo =0.10.1.2.0 =r40hfbb317b_0
-  - r-rcurl =1.98_1.2 =r40hcdcec82_1
-  - r-rematch2 =2.1.2 =r40h6115d3f_1
-  - r-reshape2 =1.4.4 =r40h0357c0b_1
-  - r-rlang =0.4.8 =r40h9e2df91_0
-  - r-rprojroot =2.0.2 =r40hc72bb7e_0
-  - r-rsqlite =2.2.1 =r40h1b71b39_0
-  - r-rstudioapi =0.13 =r40hc72bb7e_0
-  - r-scales =1.1.1 =r40h6115d3f_0
-  - r-snow =0.4_3 =r40h6115d3f_1002
-  - r-statmod =1.4.35 =r40h6e990d7_1
-  - r-stringi =1.5.3 =r40h604b29c_0
-  - r-stringr =1.4.0 =r40h6115d3f_2
-  - r-survival =3.2_7 =r40hcdcec82_0
-  - r-sys =3.4 =r40hcdcec82_0
-  - r-testthat =3.0.0 =r40he524a50_0
-  - r-tibble =3.0.4 =r40h0eb13af_0
-  - r-tidyselect =1.1.0 =r40h6115d3f_0
-  - r-utf8 =1.1.4 =r40hcdcec82_1003
-  - r-vctrs =0.3.5 =r40h9e2df91_0
-  - r-viridislite =0.3.0 =r40h6115d3f_1003
-  - r-waldo =0.2.3 =r40hc72bb7e_0
-  - r-withr =2.3.0 =r40h6115d3f_0
-  - r-xml =3.99_0.3 =r40hcdcec82_1
-  - r-xml2 =1.3.2 =r40h0357c0b_1
-  - r-xtable =1.8_4 =r40h6115d3f_3
-  - r-zeallot =0.1.0 =r40h6115d3f_1002
-  - readline =8.2
-  - sed =4.8 =he412f7d_0
\ No newline at end of file
+  - bioconductor-annotationdbi =1.72.0
+  - bioconductor-biomart =2.66.1
+  - bioconductor-deseq2 =1.50.2
+  - bioconductor-dexseq =1.56.0
+  - bioconductor-drimseq =1.38.0
+  - bioconductor-edger =4.8.2
+  - bioconductor-genomicfeatures =1.62.0
+  - bioconductor-genomicranges =1.62.1
+  - bioconductor-rtracklayer =1.70.1
+  - bioconductor-summarizedexperiment =1.40.0
+  - bioconductor-tximport =1.38.2
+  - r-base =4.5.3
+  - readline =8.3
+  - sed =4.10
diff --git a/envs/dexseq_DEU.yaml b/envs/dexseq_DEU.yaml
index f1effda5..4c699a3a 100644
--- a/envs/dexseq_DEU.yaml
+++ b/envs/dexseq_DEU.yaml
@@ -3,28 +3,24 @@ channels:
   - conda-forge
   - bioconda
   - nodefaults
-  - r
 dependencies:
-  - bcftools =1.16
-  - bioconductor-apeglm=1.28.0
-  - bioconductor-biomart=2.62.0  
-  - bioconductor-deseq2=1.46.0
-  - bioconductor-dexseq-1.52.0
-  - bioconductor-edger=4.4.0
-  - bioconductor-enhancedvolcano=1.24.0  
-  - bioconductor-rsamtools=2.22.0  
-  - bioconductor-ruvseq=1.40.0 
-  - htseq =2.0.2
-  - htslib =1.16
-  - matplotlib =3.7.0
-  - matplotlib-base =3.7.0
-  - numpy =1.24.2
+  - bcftools =1.24
+  - bioconductor-apeglm =1.28.0
+  - bioconductor-biomart =2.62.0
+  - bioconductor-deseq2 =1.46.0
+  - bioconductor-dexseq =1.52.0
+  - bioconductor-edger =4.4.0
+  - bioconductor-enhancedvolcano =1.24.0
+  - bioconductor-rsamtools =2.22.0
+  - bioconductor-ruvseq =1.40.0
+  - htseq =2.0.9
+  - matplotlib =3.3.2
+  - numpy =1.26.4
   - perl =5.32.1
-  - python =3.10.8
-  - python-dateutil =2.8.2
-  - python_abi =3.10
-  - pyyaml =6.0
-  - readline =8.2
-  - samtools =1.21
-  - sed =4.8
-  - yaml =0.2.5
\ No newline at end of file
+  - python =3.9.23
+  - python-dateutil =2.9.0.post0
+  - pyyaml =6.0.2
+  - readline =8.3
+  - samtools =1.24
+  - sed =4.10
+  - yaml =0.2.5
diff --git a/envs/dexseq_DTU.yaml b/envs/dexseq_DTU.yaml
index ba31fff5..4c699a3a 100644
--- a/envs/dexseq_DTU.yaml
+++ b/envs/dexseq_DTU.yaml
@@ -4,26 +4,23 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - bcftools =1.16
-  - bioconductor-apeglm=1.28.0
-  - bioconductor-biomart=2.62.0  
-  - bioconductor-deseq2=1.46.0  
-  - bioconductor-dexseq-1.52.0
-  - bioconductor-edger=4.4.0
-  - bioconductor-enhancedvolcano=1.24.0  
-  - bioconductor-rsamtools=2.22.0  
-  - bioconductor-ruvseq=1.40.0 
-  - htseq =2.0.2
-  - htslib =1.16
-  - matplotlib =3.7.0
-  - matplotlib-base =3.7.0
-  - numpy =1.24.2
+  - bcftools =1.24
+  - bioconductor-apeglm =1.28.0
+  - bioconductor-biomart =2.62.0
+  - bioconductor-deseq2 =1.46.0
+  - bioconductor-dexseq =1.52.0
+  - bioconductor-edger =4.4.0
+  - bioconductor-enhancedvolcano =1.24.0
+  - bioconductor-rsamtools =2.22.0
+  - bioconductor-ruvseq =1.40.0
+  - htseq =2.0.9
+  - matplotlib =3.3.2
+  - numpy =1.26.4
   - perl =5.32.1
-  - python =3.10.8
-  - python-dateutil =2.8.2
-  - python_abi =3.10
-  - pyyaml =6.0
-  - readline =8.2
-  - samtools =1.21
-  - sed =4.8
-  - yaml =0.2.5
\ No newline at end of file
+  - python =3.9.23
+  - python-dateutil =2.9.0.post0
+  - pyyaml =6.0.2
+  - readline =8.3
+  - samtools =1.24
+  - sed =4.10
+  - yaml =0.2.5
diff --git a/envs/diego_DAS.yaml b/envs/diego_DAS.yaml
index e0ec8522..28a98355 100644
--- a/envs/diego_DAS.yaml
+++ b/envs/diego_DAS.yaml
@@ -4,16 +4,16 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - bedtools =2.30.0
+  - bedtools =2.31.1
   - diego =0.1.2
-  - graphviz =2.49.1
-  - imagemagick =7.1.0_10
-  - matplotlib-base =3.5.1
-  - numpy =1.22.3
+  - graphviz =14.1.2
+  - imagemagick =7.1.2_27
+  - matplotlib-base =3.11.1
+  - numpy =2.5.2
   - perl =5.32.1
-  - python-dateutil =2.8.2
-  - pysam =0.23.0
-  - python =3.9
-  - readline =8.2
-  - samtools =1.21
-  - scipy =1.8.0
\ No newline at end of file
+  - python-dateutil =2.9.0.post0
+  - pysam =0.24.0
+  - python =3.14.6
+  - readline =8.3
+  - samtools =1.24
+  - scipy =1.18.0
diff --git a/envs/index.yaml b/envs/index.yaml
index 19a4fd8b..64153a8c 100644
--- a/envs/index.yaml
+++ b/envs/index.yaml
@@ -4,7 +4,7 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - samtools =1.21
-  - curl =7.87.0
+  - curl =8.21.0
+  - pigz =2.8
+  - samtools =1.24
   - segemehl =0.2.0
-  - pigz =2.6
\ No newline at end of file
diff --git a/envs/isoformswitchanalyzer.yaml b/envs/isoformswitchanalyzer.yaml
index 4990833a..c215763e 100644
--- a/envs/isoformswitchanalyzer.yaml
+++ b/envs/isoformswitchanalyzer.yaml
@@ -4,130 +4,13 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - bioconductor-annotate =1.66.0
-  - bioconductor-annotationdbi =1.50.0
-  - bioconductor-biobase =2.48.0
-  - bioconductor-biocfilecache =1.12.0
-  - bioconductor-biocgenerics =0.34.0
-  - bioconductor-biocparallel =1.22.0
-  - bioconductor-biomart =2.44.0
-  - bioconductor-biostrings =2.56.0
-  - bioconductor-bsgenome =1.56.0
-  - bioconductor-delayedarray =0.14.0
-  - bioconductor-deseq2 =1.39.0
-  - bioconductor-dexseq =1.34.0
-  - bioconductor-drimseq =1.16.0
-  - bioconductor-edger =4.4.0
-  - bioconductor-genefilter =1.70.0
-  - bioconductor-geneplotter =1.66.0
-  - bioconductor-genomeinfodb =1.24.0
-  - bioconductor-genomeinfodbdata =1.2.3
-  - bioconductor-genomicalignments =1.24.0
-  - bioconductor-genomicranges =1.40.0
-  - bioconductor-iranges =2.22.1
-  - bioconductor-isoformswitchanalyzer =1.10.0
-  - bioconductor-limma =3.44.1
-  - bioconductor-rhtslib =1.20.0
-  - bioconductor-rsamtools =2.4.0
-  - bioconductor-rtracklayer =1.48.0
-  - bioconductor-s4vectors =0.26.0
-  - bioconductor-summarizedexperiment =1.18.1
-  - bioconductor-tximport =1.16.0
-  - bioconductor-xvector =0.28.0
-  - bioconductor-zlibbioc =1.34.0
-  - r-askpass =1.1
-  - r-assertthat =0.2.1
-  - r-backports =1.1.8
-  - r-base =4.0.2
-  - r-bh =1.72.0_3
-  - r-bit =4.0.4
-  - r-bit64 =4.0.2
-  - r-bitops =1.0_6
-  - r-blob =1.2.1
-  - r-callr =3.4.3
-  - r-cli =2.0.2
-  - r-clipr =0.7.0
-  - r-colorspace =1.4_1
-  - r-crayon =1.3.4
-  - r-curl =4.3
-  - r-dbi =1.1.0
-  - r-dbplyr =1.4.4
-  - r-desc =1.2.0
-  - r-digest =0.6.25
-  - r-dplyr =1.0.2
-  - r-ellipsis =0.3.1
-  - r-evaluate =0.14
-  - r-fansi =0.4.1
-  - r-farver =2.0.3
-  - r-formatr =1.7
-  - r-futile.logger =1.4.3
-  - r-futile.options =1.0.1
-  - r-generics =0.0.2
-  - r-ggplot2 =3.3.2
-  - r-glue =1.4.1
-  - r-gridextra =2.3
-  - r-gtable =0.3.0
-  - r-hms =0.5.3
-  - r-httr =1.4.2
-  - r-hwriter =1.3.2
-  - r-isoband =0.2.2
-  - r-jsonlite =1.7.0
-  - r-labeling =0.3
-  - r-lambda.r =1.2.4
-  - r-lattice =0.20_41
-  - r-lifecycle =0.2.0
-  - r-locfit =1.5_9.4
-  - r-magrittr =1.5
-  - r-mass =7.3_52
-  - r-matrix =1.2_18
-  - r-matrixstats =0.56.0
-  - r-memoise =1.1.0
-  - r-mgcv =1.8_32
-  - r-mime =0.9
-  - r-munsell =0.5.0
-  - r-nlme =3.1_149
-  - r-openssl =1.4.2
-  - r-pillar =1.4.6
-  - r-pkgbuild =1.1.0
-  - r-pkgconfig =2.0.3
-  - r-pkgload =1.1.0
-  - r-plogr =0.2.0
-  - r-plyr =1.8.6
-  - r-praise =1.0.0
-  - r-prettyunits =1.1.1
-  - r-processx =3.4.3
-  - r-progress =1.2.2
-  - r-ps =1.3.4
-  - r-purrr =0.3.4
-  - r-r6 =2.4.1
-  - r-rappdirs =0.3.1
-  - r-rcolorbrewer =1.1_2
-  - r-rcpp =1.0.4.6
-  - r-rcpparmadillo =0.9.900.2.0
-  - r-rcurl =1.98_1.2
-  - r-readr =1.3.1
-  - r-reshape2 =1.4.4
-  - r-rlang =0.4.7
-  - r-rprojroot =1.3_2
-  - r-rsqlite =2.2.0
-  - r-rstudioapi =0.11
-  - r-scales =1.1.1
-  - r-snow =0.4_3
-  - r-statmod =1.4.34
-  - r-stringi =1.4.6
-  - r-stringr =1.4.0
-  - r-survival =3.2_3
-  - r-sys =3.4
-  - r-testthat =2.3.2
-  - r-tibble =3.0.3
-  - r-tidyselect =1.1.0
-  - r-utf8 =1.1.4
-  - r-vctrs =0.3.2
-  - r-venndiagram =1.6.20
-  - r-viridislite =0.3.0
-  - r-withr =2.2.0
-  - r-xml =3.99_0.3
-  - r-xtable =1.8_4
-  - r-zeallot =0.1.0
-  - readline =8.2
-  - sed =4.8
\ No newline at end of file
+  - bioconductor-deseq2 =1.50.2
+  - bioconductor-dexseq =1.56.0
+  - bioconductor-edger =4.8.2
+  - bioconductor-genomicranges =1.62.1
+  - bioconductor-isoformswitchanalyzer =2.10.0
+  - bioconductor-summarizedexperiment =1.40.0
+  - bioconductor-tximport =1.38.2
+  - r-base =4.5.3
+  - readline =8.3
+  - sed =4.10
diff --git a/envs/monsda.yaml b/envs/monsda.yaml
index 697dc095..32a77197 100644
--- a/envs/monsda.yaml
+++ b/envs/monsda.yaml
@@ -7,8 +7,8 @@ dependencies:
   - biopython =1.87
   - fastapi =0.136.1
   - grep >=3.4
-  - isort =8.0.1  
-  - monsda =1.4.0
+  - isort =8.0.1
+  - monsda =1.5.0
   - natsort =8.4.0
   - nextflow =26.04.0
   - numpy =2.4.3
@@ -26,7 +26,7 @@ dependencies:
   - snakemake-interface-report-plugins =1.3.0
   - snakemake-interface-storage-plugins =4.4.1
   - snakemake-storage-plugin-s3 =0.3.6
-  - snakemake-storage-plugin-ftp =0.1.3  
+  - snakemake-storage-plugin-ftp =0.1.3
   - snakemake-storage-plugin-http =0.3.1
   - snakemake-storage-plugin-zenodo =0.1.5
-  - uvicorn =0.46.0
\ No newline at end of file
+  - uvicorn =0.46.0
diff --git a/envs/peaks.yaml b/envs/peaks.yaml
index 7a028381..8ab1f846 100644
--- a/envs/peaks.yaml
+++ b/envs/peaks.yaml
@@ -6,222 +6,20 @@ channels:
 dependencies:
   - clustalw =2.1
   - curl =7.87.0
-  - grep =3.4
-  - perl =5.26.2
-  - perl-aceperl =1.92
-  - perl-algorithm-diff =1.1903
-  - perl-algorithm-munkres =0.08
-  - perl-apache-test =1.40
-  - perl-app-cpanminus =1.7044
-  - perl-appconfig =1.71
-  - perl-array-compare =3.0.1
-  - perl-autoloader =5.74
-  - perl-base =2.23
-  - perl-bio-asn1-entrezgene =1.73
-  - perl-bio-coordinate =1.007001
-  - perl-bio-featureio =1.6.905
-  - perl-bio-phylo =0.58
-  - perl-bio-samtools =1.43
-  - perl-bio-tools-phylo-paml =1.7.3
-  - perl-bio-tools-run-alignment-clustalw =1.7.4
-  - perl-bio-tools-run-alignment-tcoffee =1.7.4
-  - perl-bioperl =1.7.2
-  - perl-bioperl-core =1.007002
-  - perl-bioperl-run =1.007002
-  - perl-business-isbn =3.004
-  - perl-business-isbn-data =20140910.003
-  - perl-cache-cache =1.08
-  - perl-capture-tiny =0.48
-  - perl-carp =1.38
-  - perl-cgi =4.44
-  - perl-class-data-inheritable =0.08
-  - perl-class-inspector =1.34
-  - perl-class-load =0.25
-  - perl-class-load-xs =0.10
-  - perl-class-method-modifiers =2.12
-  - perl-clone =0.42
-  - perl-common-sense =3.74
-  - perl-compress-raw-zlib =2.087
-  - perl-constant =1.33
-  - perl-convert-binary-c =0.78
-  - perl-convert-binhex =1.125
-  - perl-crypt-rc4 =2.02
-  - perl-data-dumper =2.173
-  - perl-data-optlist =0.110
-  - perl-data-stag =0.14
-  - perl-date-format =2.30
-  - perl-db-file =1.855
-  - perl-dbd-sqlite =1.64
-  - perl-dbi =1.642
-  - perl-devel-globaldestruction =0.14
-  - perl-devel-overloadinfo =0.005
-  - perl-devel-stacktrace =2.04
-  - perl-digest-hmac =1.03
-  - perl-digest-md5 =2.55
-  - perl-digest-perl-md5 =1.9
-  - perl-digest-sha1 =2.13
-  - perl-dist-checkconflicts =0.11
-  - perl-dynaloader =1.25
-  - perl-email-date-format =1.005
-  - perl-encode =2.88
-  - perl-encode-locale =1.05
-  - perl-error =0.17027
-  - perl-eval-closure =0.14
-  - perl-exception-class =1.44
-  - perl-exporter =5.72
-  - perl-exporter-tiny =1.002001
-  - perl-extutils-makemaker =7.36
-  - perl-file-listing =6.04
-  - perl-file-path =2.16
-  - perl-file-slurp =9999.27
-  - perl-file-slurp-tiny =0.004
-  - perl-file-sort =1.01
-  - perl-file-temp =0.2304
-  - perl-file-which =1.23
-  - perl-findbin-real =1.05
-  - perl-font-afm =1.20
-  - perl-font-ttf =1.06
-  - perl-gd =2.68
-  - perl-getopt-long =2.50
-  - perl-graph =0.9704
-  - perl-graphviz =2.24
-  - perl-html-element-extended =1.18
-  - perl-html-entities-numbered =0.04
-  - perl-html-formatter =2.16
-  - perl-html-parser =3.72
-  - perl-html-tableextract =2.13
-  - perl-html-tagset =3.20
-  - perl-html-tidy =1.60
-  - perl-html-tree =5.07
-  - perl-html-treebuilder-xpath =0.14
-  - perl-http-cookies =6.04
-  - perl-http-daemon =6.01
-  - perl-http-date =6.02
-  - perl-http-message =6.18
-  - perl-http-negotiate =6.01
-  - perl-image-info =1.38
-  - perl-image-size =3.300
-  - perl-io-html =1.001
-  - perl-io-sessiondata =1.03
-  - perl-io-socket-ssl =2.066
-  - perl-io-string =1.08
-  - perl-io-stringy =2.111
-  - perl-io-tty =1.12
-  - perl-ipc-run =20180523.0
-  - perl-ipc-sharelite =0.17
-  - perl-jcode =2.07
-  - perl-json =4.02
-  - perl-json-xs =2.34
-  - perl-lib =0.63
-  - perl-libwww-perl =6.39
-  - perl-libxml-perl =0.08
-  - perl-list-moreutils =0.428
-  - perl-list-moreutils-xs =0.428
-  - perl-list-util =1.38
-  - perl-lwp-mediatypes =6.04
-  - perl-lwp-protocol-https =6.07
-  - perl-lwp-simple =6.15
-  - perl-mailtools =2.21
-  - perl-math-cdf =0.1
-  - perl-math-derivative =1.01
-  - perl-math-random =0.72
-  - perl-math-round =0.07
-  - perl-math-spline =0.02
-  - perl-mime-base64 =3.15
-  - perl-mime-lite =3.030
-  - perl-mime-tools =5.508
-  - perl-mime-types =2.17
-  - perl-mldbm =2.05
-  - perl-module-implementation =0.09
-  - perl-module-load =0.32
-  - perl-module-runtime =0.016
-  - perl-module-runtime-conflicts =0.003
-  - perl-moo =2.003004
-  - perl-moose =2.2011
-  - perl-mozilla-ca =20180117
-  - perl-mro-compat =0.13
-  - perl-net-http =6.19
-  - perl-net-ssleay =1.88
-  - perl-ntlm =1.09
-  - perl-ole-storage_lite =0.19
-  - perl-package-deprecationmanager =0.17
-  - perl-package-stash =0.38
-  - perl-package-stash-xs =0.28
-  - perl-params-util =1.07
-  - perl-parent =0.236
-  - perl-parse-recdescent =1.967015
-  - perl-pathtools =3.75
-  - perl-pdf-api2 =2.035
-  - perl-perlio-gzip =0.20
-  - perl-pod-escapes =1.07
-  - perl-pod-usage =1.69
-  - perl-postscript =0.06
-  - perl-role-tiny =2.000008
-  - perl-scalar-list-utils =1.52
-  - perl-set-scalar =1.29
-  - perl-soap-lite =1.19
-  - perl-socket =2.027
-  - perl-sort-naturally =1.03
-  - perl-spreadsheet-parseexcel =0.65
-  - perl-spreadsheet-writeexcel =2.40
-  - perl-statistics-descriptive =3.0702
-  - perl-storable =3.15
-  - perl-sub-exporter =0.987
-  - perl-sub-exporter-progressive =0.001013
-  - perl-sub-identify =0.14
-  - perl-sub-install =0.928
-  - perl-sub-name =0.21
-  - perl-sub-quote =2.006003
-  - perl-sub-uplevel =0.2800
-  - perl-svg =2.84
-  - perl-svg-graph =0.02
-  - perl-task-weaken =1.06
-  - perl-template-toolkit =2.26
-  - perl-test =1.26
-  - perl-test-deep =1.128
-  - perl-test-differences =0.67
-  - perl-test-exception =0.43
-  - perl-test-harness =3.42
-  - perl-test-leaktrace =0.16
-  - perl-test-most =0.35
-  - perl-test-requiresinternet =0.05
-  - perl-test-warn =0.36
-  - perl-text-diff =1.45
-  - perl-tie-hash-indexed =0.05
-  - perl-tie-ixhash =1.23
-  - perl-time-hires =1.9760
-  - perl-time-local =1.28
-  - perl-timedate =2.30
-  - perl-tree-dag_node =1.31
-  - perl-try-tiny =0.30
-  - perl-type-tiny =1.004004
-  - perl-types-serialiser =1.0
-  - perl-unicode-map =0.112
-  - perl-uri =1.76
-  - perl-www-robotrules =6.02
-  - perl-xml-dom =1.46
-  - perl-xml-dom-xpath =0.14
-  - perl-xml-filter-buffertext =1.01
-  - perl-xml-libxml =2.0132
-  - perl-xml-libxslt =1.94
-  - perl-xml-namespacesupport =1.12
-  - perl-xml-parser =2.44_01
-  - perl-xml-regexp =0.04
-  - perl-xml-sax =1.02
-  - perl-xml-sax-base =1.09
-  - perl-xml-sax-expat =0.51
-  - perl-xml-sax-writer =0.57
-  - perl-xml-simple =2.25
-  - perl-xml-twig =3.52
-  - perl-xml-writer =0.625
-  - perl-xml-xpath =1.44
-  - perl-xml-xpathengine =0.14
-  - perl-xsloader =0.24
-  - perl-yaml =1.29
-  - pigz =2.6
-  - pip =22.3.1
-  - python =3.7.16
-  - readline =8.2
-  - setuptools =66.1.0
-  - sqlite =3.40.1
-  - t_coffee =11.0.8
\ No newline at end of file
+  - grep =3.12
+  - perl =5.22.0.1
+  - perl-bioperl =1.6.924
+  - perl-bioperl-core =1.6.924
+  - perl-bioperl-run =1.006900
+  - perl-gd =2.56
+  - perl-graphviz =2.20
+  - perl-html-tree =5.03
+  - perl-libwww-perl =6.15
+  - perl-xml-twig =3.49
+  - pigz =2.8
+  - pip =21.3.1
+  - python =3.6.15
+  - readline =8.3
+  - setuptools =58.0.4
+  - sqlite =3.53.4
+  - t_coffee =11.0.8
diff --git a/envs/trimm.yaml b/envs/trimm.yaml
index 5c6aa9fb..155e1cbc 100644
--- a/envs/trimm.yaml
+++ b/envs/trimm.yaml
@@ -4,12 +4,12 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - bbmap =38.22
-  - cutadapt =1.18
-  - fastqc =0.11.8
-  - trim-galore =0.5.0
-  - perl =5.26.2
-  - pigz =2.6
-  - pip =18.1
-  - python =3.9
+  - bbmap =40.02
+  - cutadapt =5.2
+  - fastqc =0.12.1
+  - trim-galore =2.3.0
+  - perl =5.32.1
+  - pigz =2.8
+  - pip =26.2.1
+  - python =3.13.15
   - rename =1.601

From 0db4d11ad655968530f97ce72500a93c880caf8b Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 13 Aug 2026 11:00:56 +0200
Subject: [PATCH 22/80] small fix for feature selection in counting without
 countreads

---
 MONSDA/Configurator.py     |  2 ++
 tests/test_Configurator.py | 70 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 tests/test_Configurator.py

diff --git a/MONSDA/Configurator.py b/MONSDA/Configurator.py
index 8cb5ec66..2ceed78b 100755
--- a/MONSDA/Configurator.py
+++ b/MONSDA/Configurator.py
@@ -1569,7 +1569,9 @@ def set_workflows(wf=None):
             if (
                 "FEATURES" in project.baseDict[workflow].keys()
                 and not project.workflowsDict[workflow]["FEATURES"]
+                and "countreads" in tools_to_use
             ):
+                opt_dict = NestedDefaultDict()
                 number = 1
                 for k in project.baseDict[workflow]["FEATURES"].keys():
                     opt_dict[number] = k
diff --git a/tests/test_Configurator.py b/tests/test_Configurator.py
new file mode 100644
index 00000000..91b890e2
--- /dev/null
+++ b/tests/test_Configurator.py
@@ -0,0 +1,70 @@
+import importlib
+import sys
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("snakemake")
+
+import snakemake.common.configfile as configfile
+
+REPO = Path(__file__).resolve().parents[1]
+ORIGINAL_LOAD_CONFIGFILE = configfile.load_configfile
+
+
+def _load_repo_template(_):
+    return ORIGINAL_LOAD_CONFIGFILE(
+        str(REPO / "configs" / "template_base_commented.json")
+    )
+
+
+configfile.load_configfile = _load_repo_template
+original_argv = sys.argv
+sys.argv = [sys.argv[0]]
+configurator = importlib.import_module("MONSDA.Configurator")
+sys.argv = original_argv
+configfile.load_configfile = ORIGINAL_LOAD_CONFIGFILE
+
+
+@pytest.mark.parametrize(
+    ("tool_answer", "expect_features"),
+    [("1", True), ("2", False), ("1,2", True)],
+)
+def test_counting_features_only_prompted_for_countreads(
+    monkeypatch, tool_answer, expect_features
+):
+    project = configurator.PROJECT()
+    project.baseDict["COUNTING"] = {
+        "TOOLS": {
+            "countreads": "featureCounts",
+            "salmon": "salmon",
+            "oarfish": "oarfish",
+            "alevinfry": "alevin-fry",
+            "simpleaf": "simpleaf",
+        },
+        "FEATURES": {"exon": "gene_id", "gene": "gene_id"},
+    }
+    project.workflowsDict["COUNTING"]
+    guide = configurator.GUIDE()
+    prompts = []
+
+    def display(options=None, question=None, **_):
+        prompts.append((question, dict(options or {})))
+        if question.startswith("Select from these available Tools"):
+            configurator.guide.answer = tool_answer
+        elif question.startswith("Select from these available FEATURES"):
+            configurator.guide.answer = "1,2"
+
+    monkeypatch.setattr(configurator, "project", project, raising=False)
+    monkeypatch.setattr(configurator, "guide", guide, raising=False)
+    monkeypatch.setattr(configurator, "pickle_unfinished", lambda _: None)
+    monkeypatch.setattr(configurator, "show_settings", lambda: None)
+    monkeypatch.setattr(configurator.guide, "display", display)
+    monkeypatch.setattr(configurator.guide, "clear", lambda *_: None)
+
+    configurator.set_workflows("COUNTING")
+
+    feature_prompts = [entry for entry in prompts if "FEATURES" in entry[0]]
+    assert bool(feature_prompts) is expect_features
+    if expect_features:
+        assert feature_prompts[0][1] == {1: "exon", 2: "gene"}

From cea1f23a10cdfda786ae200ef1e87264ab4af7b5 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 13 Aug 2026 13:42:46 +0200
Subject: [PATCH 23/80] rammap via conda env

---
 containers/apptainer/rammap.def | 23 +++++++++++++++++++++++
 envs/rammap.yaml                |  3 +--
 tests/test_Workflows.py         | 10 ++++++++++
 workflows/rammap.nf             |  8 +++-----
 workflows/rammap.smk            |  8 +++-----
 5 files changed, 40 insertions(+), 12 deletions(-)
 create mode 100644 containers/apptainer/rammap.def

diff --git a/containers/apptainer/rammap.def b/containers/apptainer/rammap.def
new file mode 100644
index 00000000..0b82bf70
--- /dev/null
+++ b/containers/apptainer/rammap.def
@@ -0,0 +1,23 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+   
+%files
+    /home/fall/Gits/Monsda/envs/rammap.yaml /opt/envs/
+    /home/fall/Gits/Monsda/scripts /opt/MONSDA/
+
+%environment
+   
+%post
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/rammap.yaml
+    
+    ENV_NAME=rammap
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+   
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/rammap.yaml -p /opt/conda/envs/$ENV_NAME
+    conda clean --all
+   
+%runscript
+    exec "$@"
diff --git a/envs/rammap.yaml b/envs/rammap.yaml
index 961a2337..2e613e27 100644
--- a/envs/rammap.yaml
+++ b/envs/rammap.yaml
@@ -4,8 +4,7 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - rust >=1.75
-  - git
+  - rammap =1.1.2
   - zlib
   - pigz =2.6
   - samtools =1.21
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index 65230635..8542a060 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -472,3 +472,13 @@ def test_static_container_environments_exist():
     available = set(environment_names(REPO))
     assert static
     assert static <= available
+
+
+def test_rammap_is_provided_by_environment_without_runtime_install():
+    environment = (REPO / "envs" / "rammap.yaml").read_text()
+    assert "rammap =1.1.2" in environment
+    for suffix in ("smk", "nf"):
+        workflow = (REPO / "workflows" / f"rammap.{suffix}").read_text()
+        assert "cargo install" not in workflow
+        assert "RAMMAPBUILD" not in workflow
+        assert "rammapbuild" not in workflow
diff --git a/workflows/rammap.nf b/workflows/rammap.nf
index c0b8d0ba..005e8869 100644
--- a/workflows/rammap.nf
+++ b/workflows/rammap.nf
@@ -12,8 +12,6 @@ MAPUIDX = MAPUIDX.replace('.idx','')
 IDXPARAMS = get_always('rammap_params_INDEX') ?: ''
 MAPPARAMS = get_always('rammap_params_MAP') ?: ''
 
-RAMMAPBUILD = 'command -v rammap >/dev/null 2>&1 || cargo install --git https://github.com/jwanglab/rammap --root ${CONDA_PREFIX:-$PWD/.cargo} ; export PATH=${CONDA_PREFIX:-$PWD/.cargo}/bin:$PATH; '
-
 //MAPPING PROCESSES
 
 process rammap_idx{
@@ -40,7 +38,7 @@ process rammap_idx{
     script:
     gen =  genome.getName()
     """
-    ${RAMMAPBUILD} $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS $gen &> index.log && ln -fs $MAPUIDXNAME rammap.idx
+    $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS $gen &> index.log && ln -fs $MAPUIDXNAME rammap.idx
     """
 
 }
@@ -79,7 +77,7 @@ process rammap_mapping{
         uf2 = fn+"_R2_unmapped.fastq.gz"
         lf = "rammap_"+fn+".log"
         """
-        ${RAMMAPBUILD} $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
         """
     }else{
         read = reads[1]
@@ -88,7 +86,7 @@ process rammap_mapping{
         uf = fn+"_unmapped.fastq.gz"
         lf = "rammap_"+fn+".log"
         """
-        ${RAMMAPBUILD} $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
         """
     }
 }
diff --git a/workflows/rammap.smk b/workflows/rammap.smk
index 67ee74c1..3e085874 100644
--- a/workflows/rammap.smk
+++ b/workflows/rammap.smk
@@ -5,8 +5,6 @@ keydict["DECOY"] = DECOY
 keydict["ENV"] = MAPPERENV
 unik = get_dict_hash(keydict)
 
-rammapbuild = 'command -v rammap >/dev/null 2>&1 || cargo install --git https://github.com/jwanglab/rammap --root ${{CONDA_PREFIX:-$PWD/.cargo}} >> {log} 2>&1; export PATH=${{CONDA_PREFIX:-$PWD/.cargo}}/bin:$PATH; '
-
 rule generate_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
@@ -18,7 +16,7 @@ rule generate_index:
     params: indexer=MAPPERBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
             linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell: rammapbuild + "{params.indexer} -t {threads} -d {output.uidx} {params.ipara} {input.fa} 2> {log} && ln -s {params.linkidx} {output.idx}"
+    shell: "{params.indexer} -t {threads} -d {output.uidx} {params.ipara} {input.fa} 2> {log} && ln -s {params.linkidx} {output.idx}"
 
 if paired == 'paired':
     rule mapping:
@@ -34,7 +32,7 @@ if paired == 'paired':
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN
-        shell: rammapbuild + "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.q1} {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+        shell: "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.q1} {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
 
 else:
     rule mapping:
@@ -48,4 +46,4 @@ else:
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp = MAPPERBIN
-        shell: rammapbuild + "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+        shell: "{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"

From a4b34efc9824eda36433d335d8983a58976b0ae0 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 14 Aug 2026 09:57:09 +0200
Subject: [PATCH 24/80] container dep fixes, added scripts for automization of
 build and push

---
 containers/apptainer/Container_skeleton.def |  2 +-
 containers/apptainer/Convert_yaml_to_def.sh | 30 +++++++++++----
 containers/apptainer/build_all_local.sh     | 42 +++++++++++++++++++++
 containers/apptainer/push_to_oras.sh        | 28 ++++++++++++++
 containers/apptainer/rustqc.def             |  2 +-
 containers/apptainer/smoke_test.sh          | 36 ++++++++++++++++++
 docker/Dockerfile                           |  2 +-
 7 files changed, 131 insertions(+), 11 deletions(-)
 mode change 100644 => 100755 containers/apptainer/Convert_yaml_to_def.sh
 create mode 100755 containers/apptainer/build_all_local.sh
 create mode 100755 containers/apptainer/push_to_oras.sh
 create mode 100755 containers/apptainer/smoke_test.sh

diff --git a/containers/apptainer/Container_skeleton.def b/containers/apptainer/Container_skeleton.def
index 31db54ad..a546bfdc 100644
--- a/containers/apptainer/Container_skeleton.def
+++ b/containers/apptainer/Container_skeleton.def
@@ -1,5 +1,5 @@
 Bootstrap: docker
-From: continuumio/miniconda3
+From: continuumio/miniconda3:latest
    
 %files
     ##environment.yaml##
diff --git a/containers/apptainer/Convert_yaml_to_def.sh b/containers/apptainer/Convert_yaml_to_def.sh
old mode 100644
new mode 100755
index 9704f151..eb6bffa5
--- a/containers/apptainer/Convert_yaml_to_def.sh
+++ b/containers/apptainer/Convert_yaml_to_def.sh
@@ -1,10 +1,24 @@
-# zsh -i Convert_yaml_to_def.sh 
+#!/usr/bin/env bash
+set -uo pipefail
 
-for i in ${HOME}/MONSDA/envs/*.yaml;do a=${i%.yaml};b=${a##*/};cat ${HOME}/MONSDA/containers/apptainer/Container_skeleton.def |sed -e "s,##environment.yaml##,${i} /opt/envs/,g" -e "s,##environment_short.yaml##,/opt/envs/${b}.yaml,g" -e "s/##ENV_NAME##/${b}/g" > ${b}.def;done
-sed -i 's,=base,=monsda_base,g' base.def
-conda activate apptainer
-mkdir -p TMP_BUILDDIR
-rm -f build.log;for i in *.def;do a=${i%.def};APPTAINER_TMPDIR="TMP_BUILDDIR"; apptainer build --force --fakeroot ${a}.sif ${i} &>> build.log;done
-rm -rf TMP_BUILDDIR
+script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
-# for i in bbduk.sif bbmap.sif bwa2.sif bwameth.sif bwa.sif ciri2.sif cutadapt.sif deseq2_DE.sif dexseq_DEU.sif diego_DAS.sif dorado.sif drimseq_DTU.sif edger_DE.sif fastp.sif fastqc.sif guppy.sif hisat2.sif index.sif kallisto.sif macs.sif minimap.sif perl.sif picard.sif piranha.sif qc.sif salmon.sif samtools.sif scyphy.sif segemehl3.sif segemehl.sif sra.sif star.sif summary.sif test.sif trimgalore.sif trimmomatic.sif trnascan.sif ucsc.sif umitools.sif zip.sif ;do a=${i%.sif};apptainer push ${i} oras://docker.io/jfallmann/monsda:${a};done
+for i in ${HOME}/MONSDA/envs/*.yaml; do
+    a=${i%.yaml}
+    b=${a##*/}
+    sed -e "s,##environment.yaml##,${i} /opt/envs/,g" -e "s,##environment_short.yaml##,/opt/envs/${b}.yaml,g" -e "s/##ENV_NAME##/${b}/g" "$script_dir/Container_skeleton.def" > "$script_dir/${b}.def"
+done
+sed -i 's,=base,=monsda_base,g' "$script_dir/base.def"
+mkdir -p "$script_dir/TMP_BUILDDIR"
+rm -f "$script_dir/build.log"
+for i in "$script_dir"/*.def; do
+    a=${i%.def}
+    sif=${a}.sif
+    if APPTAINER_TMPDIR="$script_dir/TMP_BUILDDIR" conda run -n apptainer apptainer build --force --fakeroot "$sif" "$i" >> "$script_dir/build.log" 2>&1 && "$script_dir/smoke_test.sh" "$sif" "$script_dir/build.log"; then
+        printf '%s\tsmoke-passed\n' "${a##*/}" | tee -a "$script_dir/build.log"
+    else
+        rm -f "$sif"
+        printf '%s\tsmoke-failed\n' "${a##*/}" | tee -a "$script_dir/build.log"
+    fi
+done
+rm -rf "$script_dir/TMP_BUILDDIR"
diff --git a/containers/apptainer/build_all_local.sh b/containers/apptainer/build_all_local.sh
new file mode 100755
index 00000000..31ec77fb
--- /dev/null
+++ b/containers/apptainer/build_all_local.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+repo=${HOME}/Gits/Monsda
+out=${HOME}/Work/Container/MONSDA
+script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
+revision=$(cd "$repo" && git rev-parse HEAD)
+mapfile -t environments < <(cd "$repo" && python scripts/container_matrix.py | python -c 'import json,sys; print("\n".join(json.load(sys.stdin)["environment"]))')
+mkdir -p "$out/logs" "$out/tmp"
+printf 'environment\tstatus\timage\n' > "$out/results.tsv"
+
+for environment in "${environments[@]}"; do
+    sif="$out/${environment}-${version}.sif"
+    log="$out/logs/${environment}-${version}.log"
+    image="local/monsda:${environment}-${version}"
+    available=$(df --output=avail -B1 "$out" | tail -1)
+    if (( available < 16106127360 )); then
+        printf '%s\t%s\t%s\n' "$environment" "stopped-low-disk" "$sif" | tee -a "$out/results.tsv"
+        break
+    fi
+    if [[ -s "$sif" ]] && "$script_dir/smoke_test.sh" "$sif" "$log"; then
+        printf '%s\t%s\t%s\n' "$environment" "existing-smoke-passed" "$sif" | tee -a "$out/results.tsv"
+        continue
+    fi
+    rm -f "$sif"
+    printf '%s\t%s\n' "$environment" "building" | tee -a "$out/build.log"
+    if ! docker build --pull --build-arg "ENVIRONMENT=$environment" --build-arg "MONSDA_VERSION=$version" --build-arg "VCS_REF=$revision" -t "$image" -f "$repo/docker/Dockerfile" "$repo" >>"$log" 2>&1; then
+        printf '%s\t%s\t%s\n' "$environment" "docker-build-failed" "$sif" | tee -a "$out/results.tsv"
+        continue
+    fi
+    if APPTAINER_TMPDIR="$out/tmp" conda run -n apptainer apptainer build --force --fakeroot "$sif" "docker-daemon://$image" >>"$log" 2>&1 && "$script_dir/smoke_test.sh" "$sif" "$log"; then
+        printf '%s\t%s\t%s\n' "$environment" "smoke-passed" "$sif" | tee -a "$out/results.tsv"
+    else
+        rm -f "$sif"
+        printf '%s\t%s\t%s\n' "$environment" "smoke-failed" "$sif" | tee -a "$out/results.tsv"
+    fi
+    docker image rm "$image" >>"$log" 2>&1 || true
+done
+
+rm -rf "$out/tmp"
+printf 'finished\n' | tee -a "$out/build.log"
diff --git a/containers/apptainer/push_to_oras.sh b/containers/apptainer/push_to_oras.sh
new file mode 100755
index 00000000..f2a127e4
--- /dev/null
+++ b/containers/apptainer/push_to_oras.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -uo pipefail
+shopt -s nullglob
+
+repo=${HOME}/Gits/Monsda
+version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
+script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+: > push-ghcr-results.tsv
+
+for sif in "$script_dir"/*-${version}.sif; do
+    printf 'Preparing %s\n' "$sif"
+    base_name=${sif##*/}
+    environment=${base_name%-${version}.sif}
+    target="oras://ghcr.io/jfallmann/monsda:${environment}-${version}"
+
+    if ! "$script_dir/smoke_test.sh" "$sif" push-ghcr.log; then
+        printf '%s\tsmoke-failed\t%s\n' "$environment" "$target" >> push-ghcr-results.tsv
+        continue
+    fi
+    printf 'Pushing %s\n' "$target"
+    if conda run -n apptainer apptainer push --allow-unsigned "$sif" "$target"; then
+        printf '%s\tpassed\t%s\n' "$environment" "$target" \
+            >> push-ghcr-results.tsv
+    else
+        printf '%s\tfailed\t%s\n' "$environment" "$target" \
+            >> push-ghcr-results.tsv
+    fi
+done 2>&1 | tee push-ghcr.log
diff --git a/containers/apptainer/rustqc.def b/containers/apptainer/rustqc.def
index 2d9f57b8..88833ec9 100644
--- a/containers/apptainer/rustqc.def
+++ b/containers/apptainer/rustqc.def
@@ -1,5 +1,5 @@
 Bootstrap: docker
-From: continuumio/miniconda3
+From: continuumio/miniconda3:latest
    
 %files
     /home/fall/MONSDA/envs/rustqc.yaml /opt/envs/
diff --git a/containers/apptainer/smoke_test.sh b/containers/apptainer/smoke_test.sh
new file mode 100755
index 00000000..b9033fc8
--- /dev/null
+++ b/containers/apptainer/smoke_test.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+sif=${1:?Usage: smoke_test.sh IMAGE.sif [LOG]}
+log=${2:-/dev/stderr}
+
+if command -v apptainer >/dev/null 2>&1; then
+    runner=(apptainer)
+else
+    runner=(conda run -n apptainer apptainer)
+fi
+
+"${runner[@]}" exec --cleanenv "$sif" sh -c '
+    report=$(mktemp)
+    found=0
+    for bindir in /opt/conda/envs/*/bin; do
+        test -d "$bindir" || continue
+        found=1
+        find "$bindir" -type f -perm /111 -exec sh -c '\''
+            for executable do
+                magic=$(od -An -tx1 -N4 "$executable" 2>/dev/null | tr -d " \n")
+                test "$magic" = 7f454c46 || continue
+                output=$(ldd "$executable" 2>&1 || true)
+                if printf "%s\n" "$output" | grep -Eq "version .+ not found"; then
+                    printf "%s\n%s\n" "$executable" "$output"
+                fi
+            done
+        '\'' sh {} + >> "$report"
+    done
+    if test "$found" -eq 0 || test -s "$report"; then
+        cat "$report" >&2
+        rm -f "$report"
+        exit 1
+    fi
+    rm -f "$report"
+' >>"$log" 2>&1
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 555ef591..e12e4cae 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,4 +1,4 @@
-FROM mambaorg/micromamba:2.0.5
+FROM mambaorg/micromamba:latest
 
 ARG ENVIRONMENT
 ARG MONSDA_VERSION

From 30238e5f7552da318cf74775c4532e2efc74fec4 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 14 Aug 2026 10:11:39 +0200
Subject: [PATCH 25/80] container push fix

---
 containers/apptainer/push_to_oras.sh | 35 +++++++++++++++++++---------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/containers/apptainer/push_to_oras.sh b/containers/apptainer/push_to_oras.sh
index f2a127e4..7da06238 100755
--- a/containers/apptainer/push_to_oras.sh
+++ b/containers/apptainer/push_to_oras.sh
@@ -2,27 +2,40 @@
 set -uo pipefail
 shopt -s nullglob
 
-repo=${HOME}/Gits/Monsda
-version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
 script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-: > push-ghcr-results.tsv
+repo_root=${HOME}/Gits/Monsda
 
-for sif in "$script_dir"/*-${version}.sif; do
+if [[ ! -f "$repo_root/scripts/container_matrix.py" ]]; then
+    printf 'Could not locate MONSDA repo root from %s\n' "$script_dir" >&2
+    exit 1
+fi
+
+version=$(python "$repo_root/scripts/container_matrix.py" --version | cut -d= -f2)
+search_dir=${1:-$PWD}
+log_file="$search_dir/push-ghcr.log"
+results_file="$search_dir/push-ghcr-results.tsv"
+: > "$results_file"
+
+matches=("$search_dir"/*-${version}.sif)
+if (( ${#matches[@]} == 0 )); then
+    printf 'No SIF files matching %s/*-%s.sif found in %s\n' "$search_dir" "$version" "$search_dir" | tee "$log_file" >&2
+    exit 1
+fi
+
+for sif in "${matches[@]}"; do
     printf 'Preparing %s\n' "$sif"
     base_name=${sif##*/}
     environment=${base_name%-${version}.sif}
     target="oras://ghcr.io/jfallmann/monsda:${environment}-${version}"
 
-    if ! "$script_dir/smoke_test.sh" "$sif" push-ghcr.log; then
-        printf '%s\tsmoke-failed\t%s\n' "$environment" "$target" >> push-ghcr-results.tsv
+    if ! "$script_dir/smoke_test.sh" "$sif" "$log_file"; then
+        printf '%s\tsmoke-failed\t%s\n' "$environment" "$target" >> "$results_file"
         continue
     fi
     printf 'Pushing %s\n' "$target"
     if conda run -n apptainer apptainer push --allow-unsigned "$sif" "$target"; then
-        printf '%s\tpassed\t%s\n' "$environment" "$target" \
-            >> push-ghcr-results.tsv
+        printf '%s\tpassed\t%s\n' "$environment" "$target" >> "$results_file"
     else
-        printf '%s\tfailed\t%s\n' "$environment" "$target" \
-            >> push-ghcr-results.tsv
+        printf '%s\tfailed\t%s\n' "$environment" "$target" >> "$results_file"
     fi
-done 2>&1 | tee push-ghcr.log
+done 2>&1 | tee "$log_file"

From 97b83d2c71eb673bc68a8fef7f2e187e3db83eaf Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 14 Aug 2026 11:35:25 +0200
Subject: [PATCH 26/80] added rastqc as drop-in replacement for fastqc with
 gtpsol

---
 containers/apptainer/rastqc.def |  23 ++++
 envs/rastqc.yaml                |   7 ++
 workflows/rastqc.nf             | 183 ++++++++++++++++++++++++++++++++
 workflows/rastqc.smk            | 113 ++++++++++++++++++++
 workflows/rastqc_dedup.nf       | 105 ++++++++++++++++++
 workflows/rastqc_dedup.smk      |  81 ++++++++++++++
 workflows/rastqc_dedup_trim.nf  | 151 ++++++++++++++++++++++++++
 workflows/rastqc_dedup_trim.smk | 103 ++++++++++++++++++
 workflows/rastqc_raw.nf         |  47 ++++++++
 workflows/rastqc_raw.smk        |  48 +++++++++
 workflows/rastqc_trim.nf        | 105 ++++++++++++++++++
 workflows/rastqc_trim.smk       |  81 ++++++++++++++
 12 files changed, 1047 insertions(+)
 create mode 100644 containers/apptainer/rastqc.def
 create mode 100644 envs/rastqc.yaml
 create mode 100644 workflows/rastqc.nf
 create mode 100644 workflows/rastqc.smk
 create mode 100644 workflows/rastqc_dedup.nf
 create mode 100644 workflows/rastqc_dedup.smk
 create mode 100644 workflows/rastqc_dedup_trim.nf
 create mode 100644 workflows/rastqc_dedup_trim.smk
 create mode 100644 workflows/rastqc_raw.nf
 create mode 100644 workflows/rastqc_raw.smk
 create mode 100644 workflows/rastqc_trim.nf
 create mode 100644 workflows/rastqc_trim.smk

diff --git a/containers/apptainer/rastqc.def b/containers/apptainer/rastqc.def
new file mode 100644
index 00000000..8ae8b178
--- /dev/null
+++ b/containers/apptainer/rastqc.def
@@ -0,0 +1,23 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+   
+%files
+    /home/fall/MONSDA/envs/rastqc.yaml /opt/envs/
+    ${HOME}/MONSDA/scripts /opt/MONSDA/
+
+%environment
+   
+%post
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/rastqc.yaml
+    
+    ENV_NAME=rastqc
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+   
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/rastqc.yaml -p /opt/conda/envs/$ENV_NAME
+    conda clean --all
+   
+%runscript
+    exec "$@"
diff --git a/envs/rastqc.yaml b/envs/rastqc.yaml
new file mode 100644
index 00000000..6610a1b3
--- /dev/null
+++ b/envs/rastqc.yaml
@@ -0,0 +1,7 @@
+name: qc
+channels:
+- bioconda
+- conda-forge
+dependencies:
+- multiqc =1.21
+- rastqc =0.1.0
diff --git a/workflows/rastqc.nf b/workflows/rastqc.nf
new file mode 100644
index 00000000..510c8778
--- /dev/null
+++ b/workflows/rastqc.nf
@@ -0,0 +1,183 @@
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('rastqc_params_QC') ?: ''
+
+//QC RAW
+process qc_raw{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_RAW{
+    take:
+    collection
+
+    main:
+    
+    qc_raw(samples_ch)
+
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+
+//QC TRIM
+
+process qc_trimmed{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_TRIMMING{
+    take: collection
+
+    main:
+    
+    qc_trimmed(collection)
+
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+
+
+//QC MAP
+
+process qc_mapped{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path map
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $map
+    FILE=\$(basename "$map")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_MAPPING{
+    take: collection
+    main:
+   
+    qc_mapped(collection)
+
+    emit:
+    qc = qc_mapped.out.fastqc_results
+}
+
+// DEDUP QC
+
+process qc_dedup{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_DEDUP{
+    take: collection
+
+    main:
+   
+    qc_dedup(collection)
+
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
diff --git a/workflows/rastqc.smk b/workflows/rastqc.smk
new file mode 100644
index 00000000..2880caeb
--- /dev/null
+++ b/workflows/rastqc.smk
@@ -0,0 +1,113 @@
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        priority: 10
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+rule qc_mapped:
+    input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
+    output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
+    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    conda:  ""+QCENV+".yaml"
+    container: "oras://jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+rule qc_uniquemapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    conda:  ""+QCENV+".yaml"
+    container: "oras://jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+rule qc_dedupmapped:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    conda:  ""+QCENV+".yaml"
+    container: "oras://jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+rule qc_uniquededup:
+    input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
+            r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
+    output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
+    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    conda:  ""+QCENV+".yaml"
+    container: "oras://jfallmann/monsda:"+QCENV+""
+    threads: MAXTHREAD
+    params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+    shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
diff --git a/workflows/rastqc_dedup.nf b/workflows/rastqc_dedup.nf
new file mode 100644
index 00000000..4dfdd419
--- /dev/null
+++ b/workflows/rastqc_dedup.nf
@@ -0,0 +1,105 @@
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('rastqc_params_QC') ?: ''
+
+// RAW QC
+process qc_raw{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_RAW{
+    take: collection
+
+    main:
+    //SAMPLE CHANNELS
+    if (PAIRED == 'paired'){
+        SAMPLES = SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        }
+    }else{
+        SAMPLES=SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+        }
+    }
+
+    samples_ch = Channel.fromPath(SAMPLES.sort())
+
+    qc_raw(samples_ch.collect())
+
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+
+
+// DEDUP QC
+
+process qc_dedup{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_DEDUP{
+    take: collection
+
+    main:
+   
+    qc_dedup(collection.collect())
+
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
diff --git a/workflows/rastqc_dedup.smk b/workflows/rastqc_dedup.smk
new file mode 100644
index 00000000..6aa8e25c
--- /dev/null
+++ b/workflows/rastqc_dedup.smk
@@ -0,0 +1,81 @@
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+#outdir = 'QC/'+str(QCENV)+'/'
+#moutdir = 'QC/Multi/'+str(QCENV)+'/'
+
+#wildcard_constraints:
+#    rawfile = '|'.join(list(SAMPLES)),
+#    read = "R1|R2"
+#    outdir = outdir,
+#    moutdir = moutdir
+
+#rule themall:
+#    input:  expand("QC/Multi/{combo}/{condition}/multiqc_report.html", moutdir=moutdir, condition=str.join(os.sep, conditiononly(SAMPLES[0], config)))
+
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+		       expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/workflows/rastqc_dedup_trim.nf b/workflows/rastqc_dedup_trim.nf
new file mode 100644
index 00000000..19d0b622
--- /dev/null
+++ b/workflows/rastqc_dedup_trim.nf
@@ -0,0 +1,151 @@
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('rastqc_params_QC') ?: ''
+
+//QC RAW
+process qc_raw{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_RAW{
+    take: collection
+
+    main:
+    //SAMPLE CHANNELS
+    if (PAIRED == 'paired'){
+        SAMPLES = SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        }
+    }else{
+        SAMPLES=SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+        }
+    }
+
+    samples_ch = Channel.fromPath(SAMPLES.sort())
+
+    qc_raw(samples_ch.collect())
+
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+
+
+//QC TRIM
+
+process qc_trimmed{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    //val collect
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_TRIMMING{
+    take: collection
+
+    main:
+    
+    qc_trimmed(collection.collect())
+
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
+
+// DEDUP QC
+
+process qc_dedup{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_DEDUP{
+    take: collection
+
+    main:
+   
+    qc_dedup(collection.collect())
+
+    emit:
+    qc = qc_dedup.out.fastqc_results
+}
diff --git a/workflows/rastqc_dedup_trim.smk b/workflows/rastqc_dedup_trim.smk
new file mode 100644
index 00000000..f76b5dc0
--- /dev/null
+++ b/workflows/rastqc_dedup_trim.smk
@@ -0,0 +1,103 @@
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+#outdir = 'QC/'+str(QCENV)+'/'
+#moutdir = 'QC/Multi/'+str(QCENV)+'/'
+
+#wildcard_constraints:
+#    rawfile = '|'.join(list(SAMPLES)),
+#    read = "R1|R2"
+#    outdir = outdir,
+#    moutdir = moutdir
+
+#rule themall:
+#    input: expand("QC/Multi/{combo}/{condition}/multiqc_report.html", moutdir=moutdir, condition=str.join(os.sep, conditiononly(SAMPLES[0], config)))
+
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+               expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
+               expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
+
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_dedup:
+        input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+               expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
+               expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
diff --git a/workflows/rastqc_raw.nf b/workflows/rastqc_raw.nf
new file mode 100644
index 00000000..b2917246
--- /dev/null
+++ b/workflows/rastqc_raw.nf
@@ -0,0 +1,47 @@
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('rastqc_params_QC') ?: ''
+
+process qc_raw{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_RAW{
+    take:
+    collection
+
+    main:
+    
+    qc_raw(samples_ch)
+
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
diff --git a/workflows/rastqc_raw.smk b/workflows/rastqc_raw.smk
new file mode 100644
index 00000000..d6e94c30
--- /dev/null
+++ b/workflows/rastqc_raw.smk
@@ -0,0 +1,48 @@
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
diff --git a/workflows/rastqc_trim.nf b/workflows/rastqc_trim.nf
new file mode 100644
index 00000000..545bb538
--- /dev/null
+++ b/workflows/rastqc_trim.nf
@@ -0,0 +1,105 @@
+QCENV=get_always('PREQCENV')
+QCBIN=get_always('PREQCBIN')
+QCPARAMS = get_always('rastqc_params_QC') ?: ''
+
+// RAW QC
+process qc_raw{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_RAW{
+    take: collection
+
+    main:
+    //SAMPLE CHANNELS
+    if (PAIRED == 'paired'){
+        SAMPLES = SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        }
+    }else{
+        SAMPLES=SAMPLES.collect{
+            element -> return "${workflow.workDir}/../FASTQ/"+element+".*fastq.gz"
+        }
+    }
+
+    samples_ch = Channel.fromPath(SAMPLES.sort())
+
+    qc_raw(samples_ch.collect())
+
+    emit:
+    qc = qc_raw.out.fastqc_results
+}
+
+// TRIMMED QC
+
+process qc_trimmed{
+    conda "$QCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$QCENV"
+    cpus THREADS
+	cache 'lenient'
+    //validExitStatus 0,1
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("zip") > 0)          "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.zip"
+        else if (filename.indexOf("html") > 0)    "QC/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.html"
+        else null
+    }
+
+    input:
+    //val collect
+    path read
+
+    output:
+    path "*.{zip,html}", emit: fastqc_results
+
+    script:
+    """
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    """
+}
+
+workflow QC_TRIMMING{
+    take: collection
+
+    main:
+    
+    qc_trimmed(collection.collect())
+
+    emit:
+    qc = qc_trimmed.out.fastqc_results
+}
diff --git a/workflows/rastqc_trim.smk b/workflows/rastqc_trim.smk
new file mode 100644
index 00000000..e6f2634e
--- /dev/null
+++ b/workflows/rastqc_trim.smk
@@ -0,0 +1,81 @@
+QCBIN, QCENV = env_bin_from_config(config, 'PREQC')
+#outdir = 'QC/'+str(QCENV)+'/'
+#moutdir = 'QC/Multi/'+str(QCENV)+'/'
+
+#wildcard_constraints:
+#    rawfile = '|'.join(list(SAMPLES)),
+#    read = "R1|R2"
+#    outdir = outdir,
+#    moutdir = moutdir
+
+#rule themall:
+#    input: expand("{moutdir}TRIMMED_RAW/{condition}/multiqc_report.html", moutdir=moutdir, condition=str.join(os.se#p, conditiononly(SAMPLES[0], config)))
+
+if paired == 'paired':
+    log.info('Running paired mode QC')
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
+        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
+                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+
+else:
+    rule qc_raw:
+        input:  r1 = "FASTQ/{rawfile}.fastq.gz"
+        output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
+        log:    "LOGS/QC/{combo}/{rawfile}_fastqc_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule qc_trimmed:
+        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
+        output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
+        log:    "LOGS/QC/{combo}/{file}_fastqc_trimmed.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: MAXTHREAD
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', "")
+        shell: "OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")"
+
+    rule multiqc:
+        input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
+               expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
+                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
+                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        conda:  ""+QCENV+".yaml"
+        container: "oras://jfallmann/monsda:"+QCENV+""
+        threads: 1
+        params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
+        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"

From 07b69587ebbde9455dd216d71bf9c16daae287cf Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 14 Aug 2026 15:14:05 +0200
Subject: [PATCH 27/80] relaxed gz constraints to allow also bgz file endings

---
 MONSDA/Configurator.py               | 11 +++++++----
 MONSDA/Params.py                     |  6 +++---
 MONSDA/Utils.py                      |  2 ++
 MONSDA/web_configurator.py           | 12 ++++++------
 configs/template_base_commented.json |  6 +++---
 containers/apptainer/smoke_test.sh   |  1 +
 docker/Dockerfile                    |  1 +
 tests/test_Configurator.py           | 23 +++++++++++++++++++++++
 tests/test_Utils.py                  | 26 +++++++++++++++++++++-----
 workflows/annotatebed.smk            | 18 +++++++++---------
 workflows/countreads.nf              |  2 +-
 workflows/countreads.smk             |  8 ++++----
 workflows/deseq2_DE.nf               |  2 +-
 workflows/deseq2_DE.smk              |  2 +-
 workflows/dexseq_DEU.nf              |  2 +-
 workflows/dexseq_DEU.smk             | 16 +++++++++++-----
 workflows/edger_DE.nf                |  2 +-
 workflows/edger_DE.smk               |  2 +-
 workflows/edger_DEU.smk              |  2 +-
 workflows/macs2.smk                  |  6 +++---
 workflows/macs3.smk                  |  6 +++---
 workflows/manipulate_genome.smk      | 16 ++++++++--------
 workflows/peaks.smk                  | 24 ++++++++++++------------
 workflows/piranha.smk                | 22 +++++++++++-----------
 workflows/scyphy.smk                 | 24 ++++++++++++------------
 workflows/ucsc.smk                   |  6 +++---
 26 files changed, 150 insertions(+), 98 deletions(-)

diff --git a/MONSDA/Configurator.py b/MONSDA/Configurator.py
index 2ceed78b..d99eee43 100755
--- a/MONSDA/Configurator.py
+++ b/MONSDA/Configurator.py
@@ -187,10 +187,10 @@ def proof_input(self, whitespace, proof=None, spec=None):
                 if not a:
                     self.answer = a
                     break
-                ending = proof.replace("end_exist_", "") + "$"
-                if not re.findall(ending, a):
+                endings = proof.replace("end_exist_", "").split("|")
+                if not any(a.endswith(ending) for ending in endings):
                     self.clear(2)
-                    prRed(f"Nope, file has to end with '{ending.replace('$','')}'")
+                    prRed(f"Nope, file has to end with '{' or '.join(endings)}'")
                     continue
                 elif not os.path.isfile(a):
                     self.clear(2)
@@ -1169,7 +1169,10 @@ def set_settings():
                     else:
                         s = last_answer
                     if key in ["GTF", "GFF"]:
-                        p = f"end_exist_.{key.lower()}.gz"
+                        suffix = f".{key.lower()}"
+                        p = f"end_exist_{suffix}|{suffix}.gz|{suffix}.bgz"
+                    elif key == "REFERENCE":
+                        p = "end_exist_.fa|.fa.gz|.fa.bgz"
                     elif key == "IP":
                         p = None
                     else:
diff --git a/MONSDA/Params.py b/MONSDA/Params.py
index fb6767e1..bb9dc5d7 100644
--- a/MONSDA/Params.py
+++ b/MONSDA/Params.py
@@ -160,9 +160,9 @@ def samplesheet_to_settings(samplesheet_path: str) -> dict:
       SAMPLE     - sample name / accession
       GROUP      - group label for differential analysis
       SEQUENCING - e.g. ``paired`` or ``single``
-      REFERENCE  - path to genome FASTA (.fa.gz)
-      GTF        - path to GTF annotation (.gtf.gz)  [optional]
-      GFF        - path to GFF annotation (.gff.gz)  [optional]
+      REFERENCE  - path to genome FASTA (.fa, .fa.gz or .fa.bgz)
+      GTF        - path to GTF annotation (.gtf, .gtf.gz or .gtf.bgz)  [optional]
+      GFF        - path to GFF annotation (.gff, .gff.gz or .gff.bgz)  [optional]
       INDEX      - path to pre-built index            [optional]
       PREFIX     - mapper index prefix                [optional]
       DECOY      - path to decoy file                 [optional]
diff --git a/MONSDA/Utils.py b/MONSDA/Utils.py
index a9a93fe6..cc30de93 100644
--- a/MONSDA/Utils.py
+++ b/MONSDA/Utils.py
@@ -1130,6 +1130,8 @@ def check_ref(reference:str) -> str:
         return reference
     elif os.path.exists(os.path.abspath(reference + ".gz")):
         return reference + ".gz"
+    elif os.path.exists(os.path.abspath(reference + ".bgz")):
+        return reference + ".bgz"
 
 
 @check_run
diff --git a/MONSDA/web_configurator.py b/MONSDA/web_configurator.py
index ce964980..86cc5407 100644
--- a/MONSDA/web_configurator.py
+++ b/MONSDA/web_configurator.py
@@ -1436,23 +1436,23 @@ def root() -> str:
           </select>
         </div>
         <div>
-          <label>Reference genome (.fa.gz)</label>
+          <label>Reference genome (.fa, .fa.gz or .fa.bgz)</label>
           <div class="pathline">
-            <input class="cond-reference" id="${id}_ref" value="${escHtml(c.reference)}" placeholder="/path/to/genome.fa.gz" />
+            <input class="cond-reference" id="${id}_ref" value="${escHtml(c.reference)}" placeholder="/path/to/genome.fa" />
             <button type="button" onclick="openPathBrowser('${id}_ref','all')">Browse&hellip;</button>
           </div>
         </div>
         <div>
-          <label>GTF annotation (.gtf.gz)</label>
+          <label>GTF annotation (.gtf, .gtf.gz or .gtf.bgz)</label>
           <div class="pathline">
-            <input class="cond-gtf" id="${id}_gtf" value="${escHtml(c.gtf)}" placeholder="/path/to/annotation.gtf.gz" />
+            <input class="cond-gtf" id="${id}_gtf" value="${escHtml(c.gtf)}" placeholder="/path/to/annotation.gtf" />
             <button type="button" onclick="openPathBrowser('${id}_gtf','all')">Browse&hellip;</button>
           </div>
         </div>
         <div>
-          <label>GFF annotation (optional)</label>
+          <label>GFF annotation (.gff, .gff.gz or .gff.bgz; optional)</label>
           <div class="pathline">
-            <input class="cond-gff" id="${id}_gff" value="${escHtml(c.gff)}" placeholder="(optional)" />
+            <input class="cond-gff" id="${id}_gff" value="${escHtml(c.gff)}" placeholder="/path/to/annotation.gff" />
             <button type="button" onclick="openPathBrowser('${id}_gff','all')">Browse&hellip;</button>
           </div>
         </div>
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index 4fb0cfec..649f4cd9 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -15,12 +15,12 @@
       "TYPES": "Please enter a comma separated list for this setting matching your sample list, i.e. each sample should have a matching entry. Can be left blank.",
       "BATCHES": "Please enter a comma separated list for this setting matching your sample list, i.e. each sample should have a matching entry. Can be left blank.",
       "SEQUENCING": "single or paired or singlecell and stranded info [rf,fr,ff,unstranded (or empty)] comma separated",
-      "REFERENCE": "set path to reference, '.fa.gz' ending expected",
+      "REFERENCE": "set path to reference, '.fa', '.fa.gz' or '.fa.bgz' ending expected",
       "DECOY": "set path to decoy file if tool for mapping/counting needs decoys, like e.g. salmon",
       "INDEX": "set path to index, default index to use for mapping with this settings",
       "PREFIX": "if needed, prefix for mapping software can be set here",
-      "GTF": "set path to gtf, '.gtf.gz' ending expected, THIS WILL BE USED WHENEVER POSSIBLE OR NOT DEFINED OTHERWISE",
-      "GFF": "set path to gff, '.gff.gz' ending expected. THIS WILL BE USED WHEN GTF IS NOT AVAILABLE BUT ANNOTATION IS REQUIRED OR IF TOOL REQUIRES GFF FORMAT",
+      "GTF": "set path to gtf, '.gtf', '.gtf.gz' or '.gtf.bgz' ending expected, THIS WILL BE USED WHENEVER POSSIBLE OR NOT DEFINED OTHERWISE",
+      "GFF": "set path to gff, '.gff', '.gff.gz' or '.gff.bgz' ending expected. THIS WILL BE USED WHEN GTF IS NOT AVAILABLE BUT ANNOTATION IS REQUIRED OR IF TOOL REQUIRES GFF FORMAT",
       "IP": "OPTIONAL if PEAKS is run and files need specific processing, eg. for iCLIP protocol"
     },
     "SAMPLES": [],
diff --git a/containers/apptainer/smoke_test.sh b/containers/apptainer/smoke_test.sh
index b9033fc8..e9444788 100755
--- a/containers/apptainer/smoke_test.sh
+++ b/containers/apptainer/smoke_test.sh
@@ -12,6 +12,7 @@ fi
 
 "${runner[@]}" exec --cleanenv "$sif" sh -c '
     report=$(mktemp)
+    test -f /opt/MONSDA/scripts/Analysis/build_count_table_simple.py || exit 1
     found=0
     for bindir in /opt/conda/envs/*/bin; do
         test -d "$bindir" || continue
diff --git a/docker/Dockerfile b/docker/Dockerfile
index e12e4cae..88913242 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -10,6 +10,7 @@ LABEL org.opencontainers.image.version="${MONSDA_VERSION}"
 LABEL org.opencontainers.image.title="MONSDA ${ENVIRONMENT} environment"
 
 COPY --chown=$MAMBA_USER:$MAMBA_USER envs/${ENVIRONMENT}.yaml /tmp/environment.yaml
+COPY --chown=$MAMBA_USER:$MAMBA_USER scripts /opt/MONSDA/scripts
 
 RUN micromamba create --yes --prefix /opt/conda/envs/monsda --file /tmp/environment.yaml \
     && micromamba clean --all --yes
diff --git a/tests/test_Configurator.py b/tests/test_Configurator.py
index 91b890e2..ad99f5e3 100644
--- a/tests/test_Configurator.py
+++ b/tests/test_Configurator.py
@@ -68,3 +68,26 @@ def display(options=None, question=None, **_):
     assert bool(feature_prompts) is expect_features
     if expect_features:
         assert feature_prompts[0][1] == {1: "exon", 2: "gene"}
+
+
+@pytest.mark.parametrize(
+    ("suffix", "proof"),
+    [
+        (".fa", "end_exist_.fa|.fa.gz|.fa.bgz"),
+        (".fa.gz", "end_exist_.fa|.fa.gz|.fa.bgz"),
+        (".fa.bgz", "end_exist_.fa|.fa.gz|.fa.bgz"),
+        (".gtf", "end_exist_.gtf|.gtf.gz|.gtf.bgz"),
+        (".gtf.gz", "end_exist_.gtf|.gtf.gz|.gtf.bgz"),
+        (".gtf.bgz", "end_exist_.gtf|.gtf.gz|.gtf.bgz"),
+        (".gff", "end_exist_.gff|.gff.gz|.gff.bgz"),
+        (".gff.gz", "end_exist_.gff|.gff.gz|.gff.bgz"),
+        (".gff.bgz", "end_exist_.gff|.gff.gz|.gff.bgz"),
+    ],
+)
+def test_reference_and_annotation_formats(monkeypatch, tmp_path, suffix, proof):
+    path = tmp_path / f"input{suffix}"
+    path.write_text("test")
+    monkeypatch.setattr("builtins.input", lambda _: str(path))
+    guide = configurator.GUIDE()
+    guide.proof_input(False, proof)
+    assert guide.answer == str(path)
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index d2b6dcf4..b54630b8 100755
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -245,11 +245,27 @@ def test_cluster2trna(self):
             os.remove(path)
 
     def test_check_ref(self):
-        reference = "test_ref"
-        with open(reference, "w") as f:
-            f.write("test")
-        self.assertEqual(check_ref(reference), reference)
-        os.remove(reference)
+        with tempfile.TemporaryDirectory() as directory:
+            reference = os.path.join(directory, "reference.fa")
+            with open(reference, "w") as f:
+                f.write("test")
+            self.assertEqual(check_ref(reference), reference)
+
+            gzip_reference = os.path.join(directory, "reference_gzip.fa.gz")
+            with open(gzip_reference, "w") as f:
+                f.write("test")
+            self.assertEqual(
+                check_ref(os.path.join(directory, "reference_gzip.fa")),
+                gzip_reference,
+            )
+
+            bgzip_reference = os.path.join(directory, "reference_bgzip.fa.bgz")
+            with open(bgzip_reference, "w") as f:
+                f.write("test")
+            self.assertEqual(
+                check_ref(os.path.join(directory, "reference_bgzip.fa")),
+                bgzip_reference,
+            )
 
     def test_multi_replace(self):
         repl = {"a": "1", "b": "2"}
diff --git a/workflows/annotatebed.smk b/workflows/annotatebed.smk
index d88b6357..a76e0d71 100644
--- a/workflows/annotatebed.smk
+++ b/workflows/annotatebed.smk
@@ -68,32 +68,32 @@ rule AnnotateBed:
 
 rule UnzipGenome:
     input:  ref = REFERENCE,
-    output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '')),
-            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+    output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     log:    expand("LOGS/PEAKS/{combo}/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
     params: bins = BINS
-    shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1);chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
+    shell:  "set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1);chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
 
 rule UnzipGenome_no_us:
     input:  ref = REFERENCE,
-    output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '')),
-            fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+    output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     log:    expand("LOGS/PEAKS/{combo}/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
     params: bins = BINS
-    shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
+    shell:  "set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
     
 
 rule AddSequenceToBed:
     input:  bd = rules.AnnotateBed.output,
-            fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '')),
+            fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
     output: bed = "BED/{combo}/{file}_anno_seq_{type}.bed.gz",
             bt = temp("BED/{combo}/{file}_bed_chr_{type}.tmp"),
             bs = temp("BED/{combo}/{file}_bed_seq_{type}.tmp")
diff --git a/workflows/countreads.nf b/workflows/countreads.nf
index 735e02e7..8da0acda 100644
--- a/workflows/countreads.nf
+++ b/workflows/countreads.nf
@@ -221,7 +221,7 @@ process featurecount{
             stranded = ''
     }
     """
-    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded $COUNTMAP -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded $COUNTMAP -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
     """
 }
 
diff --git a/workflows/countreads.smk b/workflows/countreads.smk
index 2cb39417..6a3ab701 100644
--- a/workflows/countreads.smk
+++ b/workflows/countreads.smk
@@ -124,7 +124,7 @@ rule featurecount:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
 
 rule featurecount_unique:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique.bam", combo=scombo)
@@ -140,7 +140,7 @@ rule featurecount_unique:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
 
 rule featurecount_dedup:
     input:  s = expand("MAPPED/{combo}/{{file}}_mapped_sorted_dedup.bam", combo=scombo)
@@ -156,7 +156,7 @@ rule featurecount_dedup:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
 
 rule featurecount_unique_dedup:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique_dedup.bam", combo=scombo)
@@ -172,7 +172,7 @@ rule featurecount_unique_dedup:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
 
 if rundedup:
     rule summarize_counts:
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 0c446a12..73b5b3b6 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -63,7 +63,7 @@ process featurecount_deseq{
             stranded = ''
     }
     """
-    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
     """
 }
 
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 059a1044..510b18ba 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -38,7 +38,7 @@ rule featurecount_unique:
             paired   = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
 
 rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
diff --git a/workflows/dexseq_DEU.nf b/workflows/dexseq_DEU.nf
index 0fb02c75..3648bdb7 100644
--- a/workflows/dexseq_DEU.nf
+++ b/workflows/dexseq_DEU.nf
@@ -102,7 +102,7 @@ process featurecount_dexseq{
             stranded = ''
     }
     """
-    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $fcanno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $fcanno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
     """
 }
 
diff --git a/workflows/dexseq_DEU.smk b/workflows/dexseq_DEU.smk
index c09b02b5..b50e7d8f 100644
--- a/workflows/dexseq_DEU.smk
+++ b/workflows/dexseq_DEU.smk
@@ -1,6 +1,12 @@
 DEUBIN, DEUENV = env_bin_from_config(config,'DEU')
 COUNTBIN, COUNTENV = ['featureCounts','countreads_de']#env_bin_from_config(config,'COUNTING') ##PINNING subreads package to version 1.6.4 due to changes in 2.0.1 gene_id length cutoff that interfers
 
+
+def annotation_output(path, suffix):
+    compression = ".gz" if path.endswith((".gz", ".bgz")) else ""
+    return re.sub(r"\.(?:gtf|gff)(?:\.(?:gz|bgz))?$", "", path) + suffix + compression
+
+
 comparison = comparable_as_string(config,'DEU')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
@@ -19,20 +25,20 @@ rule themall:
 
 rule prepare_deu_annotation:
     input:  anno = ANNOTATION
-    output: countgtf = expand("{countanno}", countanno=ANNOTATION.replace('.gtf','_fc_dexseq.gtf')),
-            deugtf   = expand("{deuanno}", deuanno=ANNOTATION.replace('.gtf','_dexseq.gtf'))
+    output: countgtf = expand("{countanno}", countanno=annotation_output(ANNOTATION, '_fc_dexseq.gtf')),
+            deugtf   = expand("{deuanno}", deuanno=annotation_output(ANNOTATION, '_dexseq.gtf'))
     log:    expand("LOGS/DEU/{combo}/featurecount_dexseq_annotation.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
     params: bins = BINS,
             countstrand = lambda x: '-s' if stranded == 'fr' or stranded == 'rf' else ''
-    shell:  "{params.bins}/Analysis/DEU/prepare_deu_annotation.py -f {output.countgtf} {params.countstrand} {input.anno} {output.deugtf} 2>> {log}"
+    shell:  "{params.bins}/Analysis/DEU/prepare_deu_annotation.py -f {output.countgtf} {params.countstrand} <(gzip -cdfq {input.anno}) {output.deugtf} 2>> {log}"
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo),
-            countgtf = expand(rules.prepare_deu_annotation.output.countgtf, countanno=ANNOTATION.replace('.gtf','.fc_dexseq.gtf')),
-            deugtf = expand(rules.prepare_deu_annotation.output.deugtf, deuanno=ANNOTATION.replace('.gtf','.dexseq.gtf'))
+            countgtf = expand(rules.prepare_deu_annotation.output.countgtf, countanno=annotation_output(ANNOTATION, '_fc_dexseq.gtf')),
+            deugtf = expand(rules.prepare_deu_annotation.output.deugtf, deuanno=annotation_output(ANNOTATION, '_dexseq.gtf'))
     output: tmp   = temp("DEU/{combo}/Featurecounts/{file}_tmp.counts"),
             tmph = temp("DEU/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc = temp("DEU/{combo}/Featurecounts/{file}_tmp.count.gz"),
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 5a55648a..c53faa57 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -63,7 +63,7 @@ process featurecount_edger{
             stranded = ''
     }
     """
-    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
     """
 }
 
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index 90c1c5b8..dea7f25b 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -37,7 +37,7 @@ rule featurecount_unique:
             paired   = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
 
 rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
diff --git a/workflows/edger_DEU.smk b/workflows/edger_DEU.smk
index 14a65e99..0f220503 100644
--- a/workflows/edger_DEU.smk
+++ b/workflows/edger_DEU.smk
@@ -35,7 +35,7 @@ rule featurecount_unique:
             paired   = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary"
     
 
 rule prepare_count_table:
diff --git a/workflows/macs2.smk b/workflows/macs2.smk
index c3df119c..60f960ff 100644
--- a/workflows/macs2.smk
+++ b/workflows/macs2.smk
@@ -88,7 +88,7 @@ if ANNOPEAK is not None:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
                 pa = rules.AnnotatePeak.output,
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -104,7 +104,7 @@ if ANNOPEAK is not None:
 else:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -135,7 +135,7 @@ rule NormalizeBedg:
 rule PeakToTRACKS:
     input:  fw = rules.NormalizeBedg.output.fw,
             re = rules.NormalizeBedg.output.re,
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw",
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
diff --git a/workflows/macs3.smk b/workflows/macs3.smk
index c3df119c..60f960ff 100644
--- a/workflows/macs3.smk
+++ b/workflows/macs3.smk
@@ -88,7 +88,7 @@ if ANNOPEAK is not None:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
                 pa = rules.AnnotatePeak.output,
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -104,7 +104,7 @@ if ANNOPEAK is not None:
 else:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -135,7 +135,7 @@ rule NormalizeBedg:
 rule PeakToTRACKS:
     input:  fw = rules.NormalizeBedg.output.fw,
             re = rules.NormalizeBedg.output.re,
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw",
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
diff --git a/workflows/manipulate_genome.smk b/workflows/manipulate_genome.smk
index d852c147..e754e911 100644
--- a/workflows/manipulate_genome.smk
+++ b/workflows/manipulate_genome.smk
@@ -1,25 +1,25 @@
 rule UnzipGenome:
     input:  ref = REFERENCE,
-    output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '')),
-            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+    output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     log:    expand("LOGS/{combo}/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
     params: bins = BINS
-    shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
+    shell:  "set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
     #shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1);chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
 
 rule UnzipGenome_no_us:
     input:  ref = REFERENCE,
-    output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '')),
-            fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+    output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     log:    expand("LOGS/{combo}/indexfa_us.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
     params: bins = BINS
-    shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
+    shell:  "set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
     #shell:  "set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}"
diff --git a/workflows/peaks.smk b/workflows/peaks.smk
index 3068d31a..92853292 100644
--- a/workflows/peaks.smk
+++ b/workflows/peaks.smk
@@ -72,7 +72,7 @@ include: "manipulate_genome.smk"
 
 rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
     conda:  "perl.yaml"
@@ -83,7 +83,7 @@ rule extendbed:
 
 rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_revextend_{type}.log"
     conda:  "perl.yaml"
@@ -95,8 +95,8 @@ rule rev_extendbed:
 if IP == 'iCLIP':
      rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_extended_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/{file}bed2bedgraph_{type}.log"
@@ -110,8 +110,8 @@ if IP == 'iCLIP':
 elif IP == 'revCLIP':
     rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_revtrimmed_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
@@ -125,8 +125,8 @@ elif IP == 'revCLIP':
 else:
     rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
@@ -173,7 +173,7 @@ rule FindPeaks:
 
 rule AddSequenceToPeak:
     input:  pk = rules.FindPeaks.output.peak,
-            fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '')),
+            fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
@@ -200,7 +200,7 @@ if ANNOPEAK is not None:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
                 pa = rules.AnnotatePeak.output,
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -216,7 +216,7 @@ if ANNOPEAK is not None:
 else:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -247,7 +247,7 @@ rule NormalizeBedg:
 rule PeakToTRACKS:
     input:  fw = rules.NormalizeBedg.output.fw,
             re = rules.NormalizeBedg.output.re,
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw",
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
diff --git a/workflows/piranha.smk b/workflows/piranha.smk
index d377e7a3..3ecd7001 100644
--- a/workflows/piranha.smk
+++ b/workflows/piranha.smk
@@ -72,7 +72,7 @@ include: "manipulate_genome.smk"
 
 rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
     conda:  "perl.yaml"
@@ -83,7 +83,7 @@ rule extendbed:
 
 rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_revextendbed_{type}.log"
     conda:  "perl.yaml"
@@ -95,8 +95,8 @@ rule rev_extendbed:
 if IP == 'iCLIP':
      rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_extended_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/{file}bed2bedgraph_{type}.log"
@@ -110,8 +110,8 @@ if IP == 'iCLIP':
 elif IP == 'revCLIP':
     rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_revtrimmed_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
@@ -125,8 +125,8 @@ elif IP == 'revCLIP':
 else:
     rule BedToBedg:
         input:  bed = expand("BED/{scombo}/{{file}}_mapped_{{type}}.bed.gz", scombo=scombo),
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
         log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
@@ -191,7 +191,7 @@ if ANNOPEAK is not None:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
                 pa = rules.AnnotatePeak.output,
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -207,7 +207,7 @@ if ANNOPEAK is not None:
 else:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -238,7 +238,7 @@ rule NormalizeBedg:
 rule PeakToTRACKS:
     input:  fw = rules.NormalizeBedg.output.fw,
             re = rules.NormalizeBedg.output.re,
-            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw",
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
diff --git a/workflows/scyphy.smk b/workflows/scyphy.smk
index fcf1db48..7ed79514 100644
--- a/workflows/scyphy.smk
+++ b/workflows/scyphy.smk
@@ -60,7 +60,7 @@ if not all(checklist):
     rule remove_softclip:
         input:  bam = "MAPPED/{scombo}/{file}_mapped_{type}.bam",
                 fa = REFERENCE,
-                refi = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
+                refi = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
         output: bam = "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam",
                 bai = "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam.bai"
         log:    "LOGS/PEAKS/{scombo}/{file}_removesoftclip_{type}.log"
@@ -97,7 +97,7 @@ if not all(checklist):
 
 rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}_nosoftclip.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
     conda:  "perl.yaml"
@@ -108,7 +108,7 @@ rule extendbed:
 
 rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz",
-            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}_nosoftclip.bed.gz"
     log:    "LOGS/PEAKS/{scombo}/{file}_revextendbed_{type}.log"
     conda:  "perl.yaml"
@@ -119,8 +119,8 @@ rule rev_extendbed:
 
 rule BedToBedg_ext:
     input:  bed = expand("BED/{scombo}/{{file}}_mapped_extended_{{type}}_nosoftclip.bed.gz", scombo=scombo),
-            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: concat_fw = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_ext.fw.bedg.gz",
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_ext.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_ext.bedg.gz",
@@ -136,8 +136,8 @@ rule BedToBedg_ext:
 
 rule BedToBedg_rev:
     input:  bed = expand("BED/{scombo}/{{file}}_mapped_revtrimmed_{{type}}_nosoftclip.bed.gz", scombo=scombo),
-            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: concat_fw = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_rev.fw.bedg.gz",
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_rev.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_rev.bedg.gz",
@@ -153,8 +153,8 @@ rule BedToBedg_rev:
 
 rule BedToBedg:
     input:  bed = expand("BED/{scombo}/{{file}}_mapped_{{type}}_nosoftclip.bed.gz", scombo=scombo),
-            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: concat_fw = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip.fw.bedg.gz",
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip.bedg.gz",
@@ -245,7 +245,7 @@ if ANNOPEAK is not None:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
                 pa = rules.AnnotatePeak.output,
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -261,7 +261,7 @@ if ANNOPEAK is not None:
 else:
     rule PeakToBedg:
         input:  pk = "PEAKS/{combo}/{file}_peak_{type}.bed.gz",
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.bedg.gz",
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
@@ -310,7 +310,7 @@ rule PeakToTRACKS:
             map_re_ext = rules.NormalizeBedg.output.map_re_ext,
             map_fw_rev = rules.NormalizeBedg.output.map_fw_rev,
             map_re_rev = rules.NormalizeBedg.output.map_re_rev,
-            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw",
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             map_fw = "TRACKS/PEAKS/{combo}/{file}_mapped_{type}.fw.bw",
diff --git a/workflows/ucsc.smk b/workflows/ucsc.smk
index 48a9d744..57585a4b 100644
--- a/workflows/ucsc.smk
+++ b/workflows/ucsc.smk
@@ -47,8 +47,8 @@ for file in samplecond(SAMPLES, config):
 if not all(checklist):
     rule BedToBedg:
         input:  bed = "BED/{combo}/{file}_mapped_{type}.bed.gz",
-                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '')),
-                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+                fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
+                sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "TRACKS/{combo}/{file}_mapped_{type}.fw.bedg.gz",
                 re = "TRACKS/{combo}/{file}_mapped_{type}.re.bedg.gz"
         log:    "LOGS/TRACKS/{combo}/{file}_{type}_ucscbedtobedgraph.log"
@@ -75,7 +75,7 @@ rule NormalizeBedg:
 rule BedgToTRACKS:
     input:  fw = rules.NormalizeBedg.output.fw,
             re = rules.NormalizeBedg.output.re,
-            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', ''))
+            sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: fw = "TRACKS/{combo}/{file}_mapped_{type}.fw.bw",
             re = "TRACKS/{combo}/{file}_mapped_{type}.re.bw",
             tfw = temp("TRACKS/{combo}/{file}_mapped_{type}.fw.tmp"),

From f97835a63d88a46b4bf302d0ce9e6d9c799ca926 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 17 Aug 2026 10:37:55 +0200
Subject: [PATCH 28/80] fix in reference decompression when using bgzip instead
 of gzip with rammap

---
 workflows/rammap.nf  | 2 +-
 workflows/rammap.smk | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/workflows/rammap.nf b/workflows/rammap.nf
index 005e8869..41561a02 100644
--- a/workflows/rammap.nf
+++ b/workflows/rammap.nf
@@ -38,7 +38,7 @@ process rammap_idx{
     script:
     gen =  genome.getName()
     """
-    $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS $gen &> index.log && ln -fs $MAPUIDXNAME rammap.idx
+    gzip -cdfq $gen > tmp_ref.fa && $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS tmp_ref.fa &> index.log && rm -f tmp_ref.fa && ln -fs $MAPUIDXNAME rammap.idx
     """
 
 }
diff --git a/workflows/rammap.smk b/workflows/rammap.smk
index 3e085874..115eb248 100644
--- a/workflows/rammap.smk
+++ b/workflows/rammap.smk
@@ -8,7 +8,8 @@ unik = get_dict_hash(keydict)
 rule generate_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
-            uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
+            uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik),
+            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
@@ -16,7 +17,7 @@ rule generate_index:
     params: indexer=MAPPERBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
             linkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell: "{params.indexer} -t {threads} -d {output.uidx} {params.ipara} {input.fa} 2> {log} && ln -s {params.linkidx} {output.idx}"
+    shell: "gzip -cdfq {input.fa} > {output.tmpfa} && {params.indexer} -t {threads} -d {output.uidx} {params.ipara} {output.tmpfa} 2> {log} && ln -s {params.linkidx} {output.idx}"
 
 if paired == 'paired':
     rule mapping:

From 7a692c57e8093d12529a3c43a18ae924b5409e6f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 17 Aug 2026 11:20:36 +0200
Subject: [PATCH 29/80] star index tmpdir precleanup

---
 workflows/star.nf  | 2 +-
 workflows/star.smk | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/workflows/star.nf b/workflows/star.nf
index 62c3563a..1a96cd0b 100644
--- a/workflows/star.nf
+++ b/workflows/star.nf
@@ -56,7 +56,7 @@ process star_idx{
     an  = anno.getName()
 
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && rm -rf STARTMP && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
     """
 }
 
diff --git a/workflows/star.smk b/workflows/star.smk
index f7905e4f..7e31199e 100644
--- a/workflows/star.smk
+++ b/workflows/star.smk
@@ -21,7 +21,7 @@ rule generate_index:
             anno = ANNOTATION,                        
             pref = PREFIX,
             lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf TMP/star_generate_index && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
 
 if paired == 'paired':
     rule mapping:

From e82caa996724d05f9fbec42aa705d589dec846c4 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 17 Aug 2026 14:17:00 +0200
Subject: [PATCH 30/80] param warning log message fix for star index

---
 MONSDA/Params.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MONSDA/Params.py b/MONSDA/Params.py
index bb9dc5d7..b334b045 100644
--- a/MONSDA/Params.py
+++ b/MONSDA/Params.py
@@ -1938,7 +1938,7 @@ def fixRunParameters(
         return re.sub(paramToFix + " [0-9a-zA-Z\.\_\-\\\/]+", fixedParam, para)
     else:
         log.warning(
-            f"No parameter to fix {paramToFix} found or fix {fixedParam} defined for {para}!"
+            f"No parameter to fix {paramToFix} in INDEX options or fix {fixedParam} defined for {para}!"
         )
         return para
 

From 62a2f4d5e67893fadadd82c0b740208d83e8e148 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 17 Aug 2026 16:41:26 +0200
Subject: [PATCH 31/80] bgz handling unified to softlink to gz, downstream
 tools that can handle gz can also handle bgz, no check if bgz and gz files
 have same content, is silently expected and irrelevant if projects are
 created with monsda_configure

---
 MONSDA/RunMONSDA.py |  4 ++--
 MONSDA/Utils.py     | 54 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index aa9ed908..d7c5956a 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -174,7 +174,7 @@ def run_snakemake(
 ):
     try:
         logid = scriptname + ".run_snakemake: "
-        config = load_configfile(configfile)
+        config = mu.link_bgz_to_gz(load_configfile(configfile))
         subdir = "SubSnakes"
         mp.create_skeleton(subdir, skeleton)
 
@@ -498,7 +498,7 @@ def run_nextflow(
         logid = scriptname + ".run_nextflow: "
         argslist = list()
         writeout = True
-        config = load_configfile(configfile)
+        config = mu.link_bgz_to_gz(load_configfile(configfile))
         if useconda and not any(
             [
                 x in optionalargs
diff --git a/MONSDA/Utils.py b/MONSDA/Utils.py
index cc30de93..83c9fd43 100644
--- a/MONSDA/Utils.py
+++ b/MONSDA/Utils.py
@@ -1134,6 +1134,60 @@ def check_ref(reference:str) -> str:
         return reference + ".bgz"
 
 
+@check_run
+def link_bgz_to_gz(config: dict) -> dict:
+    """Replace .bgz file paths in config with .gz symlinks
+
+    Walks the config recursively, for every string value pointing to an
+    existing .bgz file a sibling symlink with .gz ending is created
+    (bgzip is gzip compatible) and the config value is replaced by the
+    .gz path, so all tools relying on .gz endings work transparently.
+
+    Parameters
+    ----------
+    config : dict
+        config to check
+
+    Returns
+    -------
+    dict
+        config with .bgz paths replaced by .gz symlinks
+    """
+    logid = scriptname + ".Utils_link_bgz_to_gz: "
+
+    def _fix(val):
+        if isinstance(val, str) and val.endswith(".bgz") and os.path.isfile(val):
+            gz = val[: -len(".bgz")] + ".gz"
+            if os.path.isfile(gz):
+                log.info(logid + f"Using existing {gz} instead of {val}")
+                return gz
+            if os.path.lexists(gz):
+                log.warning(
+                    logid
+                    + f"{gz} exists but is no readable file (broken link?), keeping {val}"
+                )
+                return val
+            try:
+                os.symlink(os.path.basename(val), gz)
+                log.info(logid + f"Linked {val} to {gz} for .gz compatibility")
+            except OSError as e:
+                log.warning(
+                    logid + f"Could not link {val} to {gz}: {e}, keeping .bgz path"
+                )
+                return val
+            return gz
+        return val
+
+    for key, value in config.items():
+        if isinstance(value, dict):
+            link_bgz_to_gz(value)
+        elif isinstance(value, list):
+            config[key] = [_fix(v) for v in value]
+        else:
+            config[key] = _fix(value)
+    return config
+
+
 @check_run
 def multi_replace(repl:str, text:str) -> str:
     """replace multiple strings

From 4379db6ce62791b22add769aefb43db45874c35e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 18 Aug 2026 11:12:02 +0200
Subject: [PATCH 32/80] fix for invalid bgzfile links

---
 MONSDA/Utils.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/MONSDA/Utils.py b/MONSDA/Utils.py
index 83c9fd43..33e04547 100644
--- a/MONSDA/Utils.py
+++ b/MONSDA/Utils.py
@@ -1156,7 +1156,13 @@ def link_bgz_to_gz(config: dict) -> dict:
     logid = scriptname + ".Utils_link_bgz_to_gz: "
 
     def _fix(val):
-        if isinstance(val, str) and val.endswith(".bgz") and os.path.isfile(val):
+        if isinstance(val, str) and val.endswith(".bgz"):
+            if not os.path.isfile(val):
+                log.warning(
+                    logid
+                    + f"{val} is not a readable file (missing or dangling link?), cannot link to .gz"
+                )
+                return val
             gz = val[: -len(".bgz")] + ".gz"
             if os.path.isfile(gz):
                 log.info(logid + f"Using existing {gz} instead of {val}")

From a3009b36cd207e4a390cd28d08786e7b8bcc9d0b Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 18 Aug 2026 11:55:55 +0200
Subject: [PATCH 33/80] rustqc can not handle blocked gzip, workaround enabled

---
 workflows/rustqc.nf  |  2 +-
 workflows/rustqc.smk | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/workflows/rustqc.nf b/workflows/rustqc.nf
index 9ce3a806..05773373 100644
--- a/workflows/rustqc.nf
+++ b/workflows/rustqc.nf
@@ -40,7 +40,7 @@ process rustqc_mapped{
     fn = file(bam).getSimpleName()
     anno = file("${workflow.workDir}/../${MAPANNO}")
     """
-    $RUSTQCBIN rna $bam --gtf $anno -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/rustqc_summary.json -o results/$fn $RUSTQCPARAMS
+    gzip -cdfq $anno > tmp_anno.gtf && $RUSTQCBIN rna $bam --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/rustqc_summary.json -o results/$fn $RUSTQCPARAMS && rm -f tmp_anno.gtf
     """
 }
 
diff --git a/workflows/rustqc.smk b/workflows/rustqc.smk
index 579715c0..44695448 100644
--- a/workflows/rustqc.smk
+++ b/workflows/rustqc.smk
@@ -15,7 +15,8 @@ RUSTQC_PAIRED = '-p' if paired == 'paired' else ''
 rule rustqc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = directory("QC/{combo}/{file}_mapped_sorted"),
-             js = "QC/{combo}/{file}_mapped_sorted/rustqc_summary.json"
+             js = "QC/{combo}/{file}_mapped_sorted/rustqc_summary.json",
+             tmpanno = temp("TMP/QC/{combo}/{file}_ms_anno.gtf")
     log:     "LOGS/{combo}/{file}_rustqc_mapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
@@ -24,13 +25,14 @@ rule rustqc_mapped:
              anno = ANNOTATION,
              paired = RUSTQC_PAIRED,
              stranded = RUSTQC_STRANDED
-    shell: "rustqc rna {input.r1} --gtf {params.anno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"
+    shell: "gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"
 
 rule rustqc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = directory("QC/{combo}/{file}_mapped_sorted_unique"),
-        js = "QC/{combo}/{file}_mapped_sorted_unique/rustqc_summary.json"
+        js = "QC/{combo}/{file}_mapped_sorted_unique/rustqc_summary.json",
+        tmpanno = temp("TMP/QC/{combo}/{file}_msu_anno.gtf")
     log:    "LOGS/{combo}/{file}_rustqc_uniquemapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
@@ -39,4 +41,4 @@ rule rustqc_uniquemapped:
              anno = ANNOTATION,
              paired = RUSTQC_PAIRED,
              stranded = RUSTQC_STRANDED
-    shell: "rustqc rna {input.r1} --gtf {params.anno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"
+    shell: "gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"

From a4ea418f54fe2568994c99c7dd89167636c638e0 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 18 Aug 2026 12:01:43 +0200
Subject: [PATCH 34/80] star index build race fix

---
 workflows/star.smk | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/workflows/star.smk b/workflows/star.smk
index 7e31199e..2ddc513f 100644
--- a/workflows/star.smk
+++ b/workflows/star.smk
@@ -10,8 +10,8 @@ rule generate_index:
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
-            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
-            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
+            tmpfa = temp(expand("TMP/{mape}_{unikey}/ref.fa", mape=MAPPERENV, unikey=unik)),
+            tmpref = temp(expand("TMP/{mape}_{unikey}/ref.anno", mape=MAPPERENV, unikey=unik))
     log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
@@ -20,8 +20,9 @@ rule generate_index:
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
             anno = ANNOTATION,                        
             pref = PREFIX,
-            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf TMP/star_generate_index && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0])),
+            stmp = expand("TMP/{mape}_{unikey}/generate_index", mape=MAPPERENV, unikey=unik)[0]
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf {params.stmp} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir {params.stmp} --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf {params.stmp}"
 
 if paired == 'paired':
     rule mapping:

From 4483e9511d091db54c5eb0b268fdb6ab02391870 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 18 Aug 2026 15:19:42 +0200
Subject: [PATCH 35/80] container def update in regards to script permissions

---
 containers/apptainer/Container_skeleton.def    |  1 +
 containers/apptainer/LoveSonesonPatro.def      |  1 +
 containers/apptainer/base.def                  |  1 +
 containers/apptainer/bbduk.def                 |  1 +
 containers/apptainer/bbmap.def                 |  1 +
 containers/apptainer/bedtools.def              |  1 +
 containers/apptainer/bwa.def                   |  1 +
 containers/apptainer/bwa2.def                  |  1 +
 containers/apptainer/bwameth.def               |  1 +
 containers/apptainer/ciri2.def                 |  1 +
 containers/apptainer/countreads.def            |  1 +
 containers/apptainer/countreads_de.def         |  1 +
 containers/apptainer/cutadapt.def              |  1 +
 containers/apptainer/deseq2_DE.def             |  1 +
 containers/apptainer/dexseq_DEU.def            |  1 +
 containers/apptainer/dexseq_DTU.def            |  1 +
 containers/apptainer/diego_DAS.def             |  1 +
 containers/apptainer/dorado.def                |  1 +
 containers/apptainer/drimseq_DTU.def           |  1 +
 containers/apptainer/edger_DAS.def             |  1 +
 containers/apptainer/edger_DE.def              |  1 +
 containers/apptainer/edger_DEU.def             |  1 +
 containers/apptainer/fastp.def                 |  1 +
 containers/apptainer/fastqc.def                |  1 +
 containers/apptainer/fgumi.def                 |  1 +
 containers/apptainer/guppy.def                 |  1 +
 containers/apptainer/hisat2.def                |  1 +
 containers/apptainer/index.def                 |  1 +
 containers/apptainer/isoformswitchanalyzer.def |  1 +
 containers/apptainer/kallisto.def              |  1 +
 containers/apptainer/macs.def                  |  1 +
 containers/apptainer/minimap.def               |  1 +
 containers/apptainer/monsda.def                |  1 +
 containers/apptainer/peaks.def                 |  1 +
 containers/apptainer/perl.def                  |  1 +
 containers/apptainer/picard.def                |  1 +
 containers/apptainer/piranha.def               |  1 +
 containers/apptainer/qc.def                    |  1 +
 containers/apptainer/rammap.def                |  1 +
 containers/apptainer/rastqc.def                |  1 +
 containers/apptainer/rustar.def                |  1 +
 containers/apptainer/rustqc.def                |  1 +
 containers/apptainer/salmon.def                |  1 +
 containers/apptainer/samtools.def              |  1 +
 containers/apptainer/scyphy.def                |  1 +
 containers/apptainer/segemehl.def              |  1 +
 containers/apptainer/segemehl3.def             |  1 +
 containers/apptainer/smoke_test.sh             |  2 +-
 containers/apptainer/spit_DTU.def              |  1 +
 containers/apptainer/sra.def                   |  1 +
 containers/apptainer/star.def                  |  1 +
 containers/apptainer/starfusion.def            |  1 +
 containers/apptainer/summary.def               |  1 +
 containers/apptainer/trimgalore.def            |  1 +
 containers/apptainer/trimm.def                 |  1 +
 containers/apptainer/trimmomatic.def           |  1 +
 containers/apptainer/trnascan.def              |  1 +
 containers/apptainer/ucsc.def                  |  1 +
 containers/apptainer/umitools.def              |  1 +
 containers/apptainer/zip.def                   |  1 +
 docker/Dockerfile                              |  1 +
 tests/test_Workflows.py                        | 12 ++++++++++++
 62 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/containers/apptainer/Container_skeleton.def b/containers/apptainer/Container_skeleton.def
index a546bfdc..f3016ffb 100644
--- a/containers/apptainer/Container_skeleton.def
+++ b/containers/apptainer/Container_skeleton.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3:latest
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x ##environment_short.yaml##
     
diff --git a/containers/apptainer/LoveSonesonPatro.def b/containers/apptainer/LoveSonesonPatro.def
index e2e66522..b73001c6 100644
--- a/containers/apptainer/LoveSonesonPatro.def
+++ b/containers/apptainer/LoveSonesonPatro.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/LoveSonesonPatro.yaml
     
diff --git a/containers/apptainer/base.def b/containers/apptainer/base.def
index 21493b0a..1b27c8f2 100644
--- a/containers/apptainer/base.def
+++ b/containers/apptainer/base.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/base.yaml
     
diff --git a/containers/apptainer/bbduk.def b/containers/apptainer/bbduk.def
index 5d4b3d84..c6a48816 100644
--- a/containers/apptainer/bbduk.def
+++ b/containers/apptainer/bbduk.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bbduk.yaml
     
diff --git a/containers/apptainer/bbmap.def b/containers/apptainer/bbmap.def
index da26b296..c2c72ac9 100644
--- a/containers/apptainer/bbmap.def
+++ b/containers/apptainer/bbmap.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bbmap.yaml
     
diff --git a/containers/apptainer/bedtools.def b/containers/apptainer/bedtools.def
index 24d8827f..c50fbcd5 100644
--- a/containers/apptainer/bedtools.def
+++ b/containers/apptainer/bedtools.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bedtools.yaml
     
diff --git a/containers/apptainer/bwa.def b/containers/apptainer/bwa.def
index 23342c56..b4dbb047 100644
--- a/containers/apptainer/bwa.def
+++ b/containers/apptainer/bwa.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bwa.yaml
     
diff --git a/containers/apptainer/bwa2.def b/containers/apptainer/bwa2.def
index 573db0a6..7461bb89 100644
--- a/containers/apptainer/bwa2.def
+++ b/containers/apptainer/bwa2.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bwa2.yaml
     
diff --git a/containers/apptainer/bwameth.def b/containers/apptainer/bwameth.def
index 220bdcdf..920807fe 100644
--- a/containers/apptainer/bwameth.def
+++ b/containers/apptainer/bwameth.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/bwameth.yaml
     
diff --git a/containers/apptainer/ciri2.def b/containers/apptainer/ciri2.def
index 9cb7b263..7a1173e3 100644
--- a/containers/apptainer/ciri2.def
+++ b/containers/apptainer/ciri2.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/ciri2.yaml
     
diff --git a/containers/apptainer/countreads.def b/containers/apptainer/countreads.def
index 2bed3b8f..540a9786 100644
--- a/containers/apptainer/countreads.def
+++ b/containers/apptainer/countreads.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/countreads.yaml
     
diff --git a/containers/apptainer/countreads_de.def b/containers/apptainer/countreads_de.def
index 33ce6440..00620c4f 100644
--- a/containers/apptainer/countreads_de.def
+++ b/containers/apptainer/countreads_de.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/countreads_de.yaml
     
diff --git a/containers/apptainer/cutadapt.def b/containers/apptainer/cutadapt.def
index 734f32bf..2121f754 100644
--- a/containers/apptainer/cutadapt.def
+++ b/containers/apptainer/cutadapt.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/cutadapt.yaml
     
diff --git a/containers/apptainer/deseq2_DE.def b/containers/apptainer/deseq2_DE.def
index 3650a52a..2f82ce09 100644
--- a/containers/apptainer/deseq2_DE.def
+++ b/containers/apptainer/deseq2_DE.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/deseq2_DE.yaml
     
diff --git a/containers/apptainer/dexseq_DEU.def b/containers/apptainer/dexseq_DEU.def
index ad9c7558..9b18be79 100644
--- a/containers/apptainer/dexseq_DEU.def
+++ b/containers/apptainer/dexseq_DEU.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/dexseq_DEU.yaml
     
diff --git a/containers/apptainer/dexseq_DTU.def b/containers/apptainer/dexseq_DTU.def
index 18e01858..59e10b8e 100644
--- a/containers/apptainer/dexseq_DTU.def
+++ b/containers/apptainer/dexseq_DTU.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/dexseq_DTU.yaml
     
diff --git a/containers/apptainer/diego_DAS.def b/containers/apptainer/diego_DAS.def
index ac1ff58f..1d18b300 100644
--- a/containers/apptainer/diego_DAS.def
+++ b/containers/apptainer/diego_DAS.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/diego_DAS.yaml
     
diff --git a/containers/apptainer/dorado.def b/containers/apptainer/dorado.def
index c674e18d..6d02bdfe 100644
--- a/containers/apptainer/dorado.def
+++ b/containers/apptainer/dorado.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/dorado.yaml
     
diff --git a/containers/apptainer/drimseq_DTU.def b/containers/apptainer/drimseq_DTU.def
index ffbe4847..9c5b2273 100644
--- a/containers/apptainer/drimseq_DTU.def
+++ b/containers/apptainer/drimseq_DTU.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/drimseq_DTU.yaml
     
diff --git a/containers/apptainer/edger_DAS.def b/containers/apptainer/edger_DAS.def
index 66edc324..93b365ae 100644
--- a/containers/apptainer/edger_DAS.def
+++ b/containers/apptainer/edger_DAS.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/edger_DAS.yaml
     
diff --git a/containers/apptainer/edger_DE.def b/containers/apptainer/edger_DE.def
index 2b76b250..c9f5a3b9 100644
--- a/containers/apptainer/edger_DE.def
+++ b/containers/apptainer/edger_DE.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/edger_DE.yaml
     
diff --git a/containers/apptainer/edger_DEU.def b/containers/apptainer/edger_DEU.def
index 758ff2d2..ec66e905 100644
--- a/containers/apptainer/edger_DEU.def
+++ b/containers/apptainer/edger_DEU.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/edger_DEU.yaml
     
diff --git a/containers/apptainer/fastp.def b/containers/apptainer/fastp.def
index 9f9af87e..5dca52c8 100644
--- a/containers/apptainer/fastp.def
+++ b/containers/apptainer/fastp.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/fastp.yaml
     
diff --git a/containers/apptainer/fastqc.def b/containers/apptainer/fastqc.def
index e50e632c..51095502 100644
--- a/containers/apptainer/fastqc.def
+++ b/containers/apptainer/fastqc.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/fastqc.yaml
     
diff --git a/containers/apptainer/fgumi.def b/containers/apptainer/fgumi.def
index 4d305696..4e8add5e 100644
--- a/containers/apptainer/fgumi.def
+++ b/containers/apptainer/fgumi.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/fgumi.yaml
     
diff --git a/containers/apptainer/guppy.def b/containers/apptainer/guppy.def
index e8a2c7d7..3472fee8 100644
--- a/containers/apptainer/guppy.def
+++ b/containers/apptainer/guppy.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/guppy.yaml
     
diff --git a/containers/apptainer/hisat2.def b/containers/apptainer/hisat2.def
index c6c8dc82..00ab1bb6 100644
--- a/containers/apptainer/hisat2.def
+++ b/containers/apptainer/hisat2.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/hisat2.yaml
     
diff --git a/containers/apptainer/index.def b/containers/apptainer/index.def
index f1b004ae..8705ea85 100644
--- a/containers/apptainer/index.def
+++ b/containers/apptainer/index.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/index.yaml
     
diff --git a/containers/apptainer/isoformswitchanalyzer.def b/containers/apptainer/isoformswitchanalyzer.def
index e9a453b9..8d337291 100644
--- a/containers/apptainer/isoformswitchanalyzer.def
+++ b/containers/apptainer/isoformswitchanalyzer.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/isoformswitchanalyzer.yaml
     
diff --git a/containers/apptainer/kallisto.def b/containers/apptainer/kallisto.def
index 6cb6db1c..90cd3ba5 100644
--- a/containers/apptainer/kallisto.def
+++ b/containers/apptainer/kallisto.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/kallisto.yaml
     
diff --git a/containers/apptainer/macs.def b/containers/apptainer/macs.def
index 09361528..795b2946 100644
--- a/containers/apptainer/macs.def
+++ b/containers/apptainer/macs.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/macs.yaml
     
diff --git a/containers/apptainer/minimap.def b/containers/apptainer/minimap.def
index 3d78d6c9..fdb79d96 100644
--- a/containers/apptainer/minimap.def
+++ b/containers/apptainer/minimap.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/minimap.yaml
     
diff --git a/containers/apptainer/monsda.def b/containers/apptainer/monsda.def
index 1142e27c..c4ee84be 100644
--- a/containers/apptainer/monsda.def
+++ b/containers/apptainer/monsda.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/monsda.yaml
     
diff --git a/containers/apptainer/peaks.def b/containers/apptainer/peaks.def
index 7ad1097e..cc2fd306 100644
--- a/containers/apptainer/peaks.def
+++ b/containers/apptainer/peaks.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/peaks.yaml
     
diff --git a/containers/apptainer/perl.def b/containers/apptainer/perl.def
index a39ecf40..1cb93b79 100644
--- a/containers/apptainer/perl.def
+++ b/containers/apptainer/perl.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/perl.yaml
     
diff --git a/containers/apptainer/picard.def b/containers/apptainer/picard.def
index cda7650b..778718af 100644
--- a/containers/apptainer/picard.def
+++ b/containers/apptainer/picard.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/picard.yaml
     
diff --git a/containers/apptainer/piranha.def b/containers/apptainer/piranha.def
index 53ce797f..cf2eda39 100644
--- a/containers/apptainer/piranha.def
+++ b/containers/apptainer/piranha.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/piranha.yaml
     
diff --git a/containers/apptainer/qc.def b/containers/apptainer/qc.def
index 4f8ce9b5..2797dfec 100644
--- a/containers/apptainer/qc.def
+++ b/containers/apptainer/qc.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/qc.yaml
     
diff --git a/containers/apptainer/rammap.def b/containers/apptainer/rammap.def
index 0b82bf70..f23a56b5 100644
--- a/containers/apptainer/rammap.def
+++ b/containers/apptainer/rammap.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/rammap.yaml
     
diff --git a/containers/apptainer/rastqc.def b/containers/apptainer/rastqc.def
index 8ae8b178..065107b8 100644
--- a/containers/apptainer/rastqc.def
+++ b/containers/apptainer/rastqc.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/rastqc.yaml
     
diff --git a/containers/apptainer/rustar.def b/containers/apptainer/rustar.def
index 1dc192de..2a7d1afd 100644
--- a/containers/apptainer/rustar.def
+++ b/containers/apptainer/rustar.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/rustar.yaml
     
diff --git a/containers/apptainer/rustqc.def b/containers/apptainer/rustqc.def
index 88833ec9..841fc35c 100644
--- a/containers/apptainer/rustqc.def
+++ b/containers/apptainer/rustqc.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3:latest
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/rustqc.yaml
     
diff --git a/containers/apptainer/salmon.def b/containers/apptainer/salmon.def
index 251eeb4a..26cc15f4 100644
--- a/containers/apptainer/salmon.def
+++ b/containers/apptainer/salmon.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/salmon.yaml
     
diff --git a/containers/apptainer/samtools.def b/containers/apptainer/samtools.def
index b54ed33c..9182a7e5 100644
--- a/containers/apptainer/samtools.def
+++ b/containers/apptainer/samtools.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/samtools.yaml
     
diff --git a/containers/apptainer/scyphy.def b/containers/apptainer/scyphy.def
index c56d6933..4d960b53 100644
--- a/containers/apptainer/scyphy.def
+++ b/containers/apptainer/scyphy.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/scyphy.yaml
     
diff --git a/containers/apptainer/segemehl.def b/containers/apptainer/segemehl.def
index c74ccff3..306399ee 100644
--- a/containers/apptainer/segemehl.def
+++ b/containers/apptainer/segemehl.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/segemehl.yaml
     
diff --git a/containers/apptainer/segemehl3.def b/containers/apptainer/segemehl3.def
index ea94815b..ac6b63fc 100644
--- a/containers/apptainer/segemehl3.def
+++ b/containers/apptainer/segemehl3.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/segemehl3.yaml
     
diff --git a/containers/apptainer/smoke_test.sh b/containers/apptainer/smoke_test.sh
index e9444788..e5fb5b86 100755
--- a/containers/apptainer/smoke_test.sh
+++ b/containers/apptainer/smoke_test.sh
@@ -12,7 +12,7 @@ fi
 
 "${runner[@]}" exec --cleanenv "$sif" sh -c '
     report=$(mktemp)
-    test -f /opt/MONSDA/scripts/Analysis/build_count_table_simple.py || exit 1
+    test -x /opt/MONSDA/scripts/Analysis/build_count_table_simple.py || exit 1
     found=0
     for bindir in /opt/conda/envs/*/bin; do
         test -d "$bindir" || continue
diff --git a/containers/apptainer/spit_DTU.def b/containers/apptainer/spit_DTU.def
index f228de5a..81b329cb 100644
--- a/containers/apptainer/spit_DTU.def
+++ b/containers/apptainer/spit_DTU.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/spit_DTU.yaml
     
diff --git a/containers/apptainer/sra.def b/containers/apptainer/sra.def
index 9b7d93ae..17bc2896 100644
--- a/containers/apptainer/sra.def
+++ b/containers/apptainer/sra.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/sra.yaml
     
diff --git a/containers/apptainer/star.def b/containers/apptainer/star.def
index 7fecd634..daeac763 100644
--- a/containers/apptainer/star.def
+++ b/containers/apptainer/star.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/star.yaml
     
diff --git a/containers/apptainer/starfusion.def b/containers/apptainer/starfusion.def
index 64818735..013cf5d3 100644
--- a/containers/apptainer/starfusion.def
+++ b/containers/apptainer/starfusion.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/starfusion.yaml
     
diff --git a/containers/apptainer/summary.def b/containers/apptainer/summary.def
index 327080a3..fb144944 100644
--- a/containers/apptainer/summary.def
+++ b/containers/apptainer/summary.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/summary.yaml
     
diff --git a/containers/apptainer/trimgalore.def b/containers/apptainer/trimgalore.def
index 993bcc2a..78090536 100644
--- a/containers/apptainer/trimgalore.def
+++ b/containers/apptainer/trimgalore.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/trimgalore.yaml
     
diff --git a/containers/apptainer/trimm.def b/containers/apptainer/trimm.def
index 5dce7490..466646bd 100644
--- a/containers/apptainer/trimm.def
+++ b/containers/apptainer/trimm.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/trimm.yaml
     
diff --git a/containers/apptainer/trimmomatic.def b/containers/apptainer/trimmomatic.def
index 4f2bff98..965b59dc 100644
--- a/containers/apptainer/trimmomatic.def
+++ b/containers/apptainer/trimmomatic.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/trimmomatic.yaml
     
diff --git a/containers/apptainer/trnascan.def b/containers/apptainer/trnascan.def
index e0b150b2..53e73e1c 100644
--- a/containers/apptainer/trnascan.def
+++ b/containers/apptainer/trnascan.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/trnascan.yaml
     
diff --git a/containers/apptainer/ucsc.def b/containers/apptainer/ucsc.def
index 5946a849..67b98789 100644
--- a/containers/apptainer/ucsc.def
+++ b/containers/apptainer/ucsc.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/ucsc.yaml
     
diff --git a/containers/apptainer/umitools.def b/containers/apptainer/umitools.def
index 53721e5f..c3844b78 100644
--- a/containers/apptainer/umitools.def
+++ b/containers/apptainer/umitools.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/umitools.yaml
     
diff --git a/containers/apptainer/zip.def b/containers/apptainer/zip.def
index f6b341d5..c6602523 100644
--- a/containers/apptainer/zip.def
+++ b/containers/apptainer/zip.def
@@ -8,6 +8,7 @@ From: continuumio/miniconda3
 %environment
    
 %post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
     ls -alrt /opt/envs
     chmod -R +x /opt/envs/zip.yaml
     
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 88913242..3c146a40 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -11,6 +11,7 @@ LABEL org.opencontainers.image.title="MONSDA ${ENVIRONMENT} environment"
 
 COPY --chown=$MAMBA_USER:$MAMBA_USER envs/${ENVIRONMENT}.yaml /tmp/environment.yaml
 COPY --chown=$MAMBA_USER:$MAMBA_USER scripts /opt/MONSDA/scripts
+RUN find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
 
 RUN micromamba create --yes --prefix /opt/conda/envs/monsda --file /tmp/environment.yaml \
     && micromamba clean --all --yes
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index 8542a060..d1d56427 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -482,3 +482,15 @@ def test_rammap_is_provided_by_environment_without_runtime_install():
         assert "cargo install" not in workflow
         assert "RAMMAPBUILD" not in workflow
         assert "rammapbuild" not in workflow
+
+
+def test_container_builds_make_command_scripts_executable():
+    chmod_command = "find /opt/MONSDA/scripts -type f"
+    definitions = [
+        path
+        for path in (REPO / "containers" / "apptainer").glob("*.def")
+        if "scripts /opt/MONSDA" in path.read_text()
+    ]
+    assert definitions
+    assert all(chmod_command in path.read_text() for path in definitions)
+    assert chmod_command in (REPO / "docker" / "Dockerfile").read_text()

From 201c121b1e9c8d2e63eed0486450b47dac11d4c3 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 18 Aug 2026 21:50:04 +0200
Subject: [PATCH 36/80] Massive overhaul of logging, now consitent across all
 workflows and snakemake/nextflow, added versions.py to collect tool versions
 used in config and export to file, all of this can be picked up by multiqc
 now and used for report generation

---
 MONSDA/RunMONSDA.py                           |  25 ++
 MONSDA/Versions.py                            | 349 ++++++++++++++++++
 ...imgalore-picard-star_DTU_dexseq_subflow.nf |  12 +-
 ...mgalore-picard-star_DTU_drimseq_subflow.nf |  12 +-
 ...trimgalore-picard-star_DTU_spit_subflow.nf |  12 +-
 ...galore-picard-star_DTU_dexseq_subsnake.smk |  24 +-
 ...alore-picard-star_DTU_drimseq_subsnake.smk |  24 +-
 ...imgalore-picard-star_DTU_spit_subsnake.smk |  24 +-
 ...-picard-star_FUSIONS_starfusion_subflow.nf |   2 +-
 ...icard-star_FUSIONS_starfusion_subsnake.smk |   8 +-
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   |  47 +--
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf |  49 +--
 .../Test_fastqc-bbduk-picard-star_subflow.nf  |  51 +--
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf |  47 +--
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf |  49 +--
 ...est_fastqc-cutadapt-picard-star_subflow.nf |  51 +--
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf |  47 +--
 ...fastqc-trimgalore-picard-rustar_subflow.nf |  49 +--
 ...t_fastqc-trimgalore-picard-star_subflow.nf |  51 +--
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk | 100 ++---
 ...st_fastqc-bbduk-picard-rustar_subsnake.smk |  98 ++---
 ...Test_fastqc-bbduk-picard-star_subsnake.smk | 107 +++---
 ...st_fastqc-cutadapt-picard-bwa_subsnake.smk | 100 ++---
 ...fastqc-cutadapt-picard-rustar_subsnake.smk |  98 ++---
 ...t_fastqc-cutadapt-picard-star_subsnake.smk | 107 +++---
 ..._fastqc-trimgalore-picard-bwa_subsnake.smk | 100 ++---
 ...stqc-trimgalore-picard-rustar_subsnake.smk |  98 ++---
 ...fastqc-trimgalore-picard-star_subsnake.smk | 107 +++---
 workflows/alevinfry.nf                        |   2 +-
 workflows/alevinfry.smk                       |   4 +-
 workflows/annotatebed.smk                     |  18 +-
 workflows/bbduk.nf                            |   2 +-
 workflows/bbduk.smk                           |   4 +-
 workflows/bwa.nf                              |   4 +-
 workflows/bwa.smk                             |  22 +-
 workflows/bwa2.nf                             |   4 +-
 workflows/bwa2.smk                            |   6 +-
 workflows/bwameth.nf                          |   4 +-
 workflows/bwameth.smk                         |   6 +-
 workflows/ciri2.nf                            |   2 +-
 workflows/ciri2.smk                           |   2 +-
 workflows/collect.nf                          |   2 +-
 workflows/countreads.nf                       |  16 +-
 workflows/countreads.smk                      |  42 +--
 workflows/cutadapt.nf                         |   2 +-
 workflows/cutadapt.smk                        |   4 +-
 workflows/deseq2_DE.nf                        |  10 +-
 workflows/deseq2_DE.smk                       |  10 +-
 workflows/dexseq_DEU.nf                       |  12 +-
 workflows/dexseq_DEU.smk                      |  12 +-
 workflows/dexseq_DTU.nf                       |   6 +-
 workflows/dexseq_DTU.smk                      |   6 +-
 workflows/diego_DAS.nf                        |  14 +-
 workflows/diego_DAS.smk                       |  16 +-
 workflows/dorado.nf                           |   2 +-
 workflows/dorado.smk                          |   2 +-
 workflows/drimseq_DTU.nf                      |   6 +-
 workflows/drimseq_DTU.smk                     |   6 +-
 workflows/dtu_base.nf                         |   6 +-
 workflows/dtu_base.smk                        |  18 +-
 workflows/edger_DAS.nf                        |  10 +-
 workflows/edger_DAS.smk                       |  10 +-
 workflows/edger_DE.nf                         |  10 +-
 workflows/edger_DE.smk                        |  10 +-
 workflows/edger_DEU.nf                        |  10 +-
 workflows/edger_DEU.smk                       |  10 +-
 workflows/fastp.nf                            |   2 +-
 workflows/fastp.smk                           |   4 +-
 workflows/fastqc.smk                          |  20 +-
 workflows/fastqc_dedup.smk                    |  12 +-
 workflows/fastqc_dedup_trim.smk               |  16 +-
 workflows/fastqc_raw.smk                      |   8 +-
 workflows/fastqc_trim.smk                     |  12 +-
 workflows/fgumi.nf                            |   2 +-
 workflows/fgumi.smk                           |   8 +-
 workflows/fgumi_dedup.nf                      |   2 +-
 workflows/fgumi_dedup.smk                     |   2 +-
 workflows/guppy.nf                            |   2 +-
 workflows/guppy.smk                           |   2 +-
 workflows/hisat2.nf                           |   4 +-
 workflows/hisat2.smk                          |   6 +-
 workflows/kallisto.nf                         |   4 +-
 workflows/kallisto.smk                        |   6 +-
 workflows/kallisto_trim.smk                   |  12 +-
 workflows/macs2.nf                            |  10 +-
 workflows/macs2.smk                           |  16 +-
 workflows/macs3.nf                            |  10 +-
 workflows/macs3.smk                           |  16 +-
 workflows/manipulate_genome.nf                |   4 +-
 workflows/manipulate_genome.smk               |   4 +-
 workflows/mapping.nf                          |   6 +-
 workflows/mapping.smk                         |   8 +-
 workflows/minimap.nf                          |   4 +-
 workflows/minimap.smk                         |   6 +-
 workflows/multiqc.nf                          |  32 +-
 workflows/multiqc.smk                         |  42 ++-
 workflows/multiqc_rustqc.nf                   |  23 +-
 workflows/multiqc_rustqc.smk                  |  14 +-
 workflows/multx.smk                           |   4 +-
 workflows/oarfish.nf                          |   2 +-
 workflows/oarfish.smk                         |   2 +-
 workflows/peaks.nf                            |  18 +-
 workflows/peaks.smk                           |  32 +-
 workflows/picard_dedup.nf                     |   4 +-
 workflows/picard_dedup.smk                    |   4 +-
 workflows/piranha.nf                          |  18 +-
 workflows/piranha.smk                         |  32 +-
 workflows/piscem.nf                           |   4 +-
 workflows/piscem.smk                          |   4 +-
 workflows/premultiqc.nf                       |  21 +-
 workflows/premultiqc.smk                      |  10 +-
 workflows/rammap.nf                           |   4 +-
 workflows/rammap.smk                          |   6 +-
 workflows/rastqc.smk                          |  20 +-
 workflows/rastqc_dedup.smk                    |  12 +-
 workflows/rastqc_dedup_trim.smk               |  16 +-
 workflows/rastqc_raw.smk                      |   8 +-
 workflows/rastqc_trim.smk                     |  12 +-
 workflows/rustar.nf                           |   6 +-
 workflows/rustar.smk                          |  20 +-
 workflows/rustqc.smk                          |   4 +-
 workflows/salmon.nf                           |   6 +-
 workflows/salmon.smk                          |  10 +-
 workflows/salmon_trim.smk                     |  12 +-
 workflows/salmonalign.nf                      |   4 +-
 workflows/salmonalign.smk                     |   6 +-
 workflows/scyphy.nf                           |  30 +-
 workflows/scyphy.smk                          |  38 +-
 workflows/segemehl.nf                         |   4 +-
 workflows/segemehl.smk                        |   6 +-
 workflows/segemehl3.nf                        |   4 +-
 workflows/segemehl3.smk                       |   6 +-
 workflows/segemehl3_bisulfite.nf              |   4 +-
 workflows/segemehl3_bisulfite.smk             |   6 +-
 workflows/segemehl_bisulfite.nf               |   4 +-
 workflows/segemehl_bisulfite.smk              |   6 +-
 workflows/simpleaf.nf                         |   4 +-
 workflows/simpleaf.smk                        |   4 +-
 workflows/spit_DTU.nf                         |   6 +-
 workflows/spit_DTU.smk                        |   6 +-
 workflows/sra.nf                              |   4 +-
 workflows/sra.smk                             |   8 +-
 workflows/star.nf                             |   6 +-
 workflows/star.smk                            |  20 +-
 workflows/starfusion.nf                       |   2 +-
 workflows/starfusion.smk                      |   8 +-
 workflows/summary.nf                          |   2 +-
 workflows/summary.smk                         |   2 +-
 workflows/trimgalore.nf                       |   2 +-
 workflows/trimgalore.smk                      |   4 +-
 workflows/ucsc.nf                             |  10 +-
 workflows/ucsc.smk                            |  12 +-
 workflows/umicollapse.nf                      |   4 +-
 workflows/umicollapse.smk                     |  16 +-
 workflows/umicollapse_dedup.nf                |   2 +-
 workflows/umitools.nf                         |   4 +-
 workflows/umitools.smk                        |  16 +-
 workflows/umitools_dedup.nf                   |   2 +-
 158 files changed, 1785 insertions(+), 1267 deletions(-)
 create mode 100644 MONSDA/Versions.py

diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index d7c5956a..8ff7d41f 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -36,6 +36,12 @@
         "LOGS" + os.sep + scriptname + ".log",
         "LOGS" + os.sep + scriptname + "_" + ts + ".log",
     )
+    # keep tool versions of the archived run with the same timestamp as its log
+    if os.path.isfile(os.path.abspath("LOGS" + os.sep + "versions.txt")):
+        shutil.copy2(
+            "LOGS" + os.sep + "versions.txt",
+            "LOGS" + os.sep + "versions_" + ts + ".txt",
+        )
 
 log = setup_logger(
     name=scriptname.lower(),
@@ -52,6 +58,7 @@
 
 import MONSDA.Params as mp
 import MONSDA.Utils as mu
+import MONSDA.Versions as mv
 import MONSDA.Workflows as mw
 
 
@@ -231,6 +238,15 @@ def run_snakemake(
         preprocess, subworkflows, postprocess = mw.get_processes(config)
         conditions = mp.get_conditions(config)
 
+        # Export versions of all tools configured to run for provenance and MultiQC
+        mv.write_versions(
+            config,
+            (preprocess or []) + (subworkflows or []) + (postprocess or []),
+            mw.envpath,
+            __version__,
+            configfile,
+        )
+
         """
         START TO PREPROCESS
         IF WE NEED TO DOWNLOAD FILES WE DO THIS NOW
@@ -564,6 +580,15 @@ def run_nextflow(
         preprocess, subworkflows, postprocess = mw.nf_get_processes(config)
         conditions = mp.get_conditions(config)
 
+        # Export versions of all tools configured to run for provenance and MultiQC
+        mv.write_versions(
+            config,
+            (preprocess or []) + (subworkflows or []) + (postprocess or []),
+            mw.envpath,
+            __version__,
+            configfile,
+        )
+
         """
         START TO PROCESS
         IF WE NEED TO DOWNLOAD FILES WE DO THIS NOW
diff --git a/MONSDA/Versions.py b/MONSDA/Versions.py
new file mode 100644
index 00000000..3c1b9ab0
--- /dev/null
+++ b/MONSDA/Versions.py
@@ -0,0 +1,349 @@
+# Versions.py ---
+
+# Export of tool versions of a MONSDA run as deduced from the config file and
+# the conda environment yaml files of the configured tools.
+
+import datetime
+import logging
+import os
+import re
+
+log = logging.getLogger(__name__)
+
+scriptname = os.path.basename(__file__).replace(".py", "")
+
+# Tools/packages that are no analysis tools and only clutter the version list
+SKIP_PACKAGES = frozenset(
+    [
+        "pip",
+        "python",
+        "setuptools",
+        "wheel",
+        "openssl",
+        "zlib",
+    ]
+)
+
+# Mapping of tool/package name to the corresponding MultiQC module name,
+# None means MultiQC has no module for this tool
+MULTIQC_MODULES = {
+    "bbmap": "bbmap",
+    "bbduk": "bbmap",
+    "bismark": "bismark",
+    "bowtie2": "bowtie2",
+    "cutadapt": "cutadapt",
+    "fastp": "fastp",
+    "fastqc": "fastqc",
+    "featurecounts": "featurecounts",
+    "hisat2": "hisat2",
+    "htseq": "htseq",
+    "kallisto": "kallisto",
+    "macs2": "macs2",
+    "macs3": "macs2",
+    "picard": "picard",
+    "qualimap": "qualimap",
+    "salmon": "salmon",
+    "samtools": "samtools",
+    "star": "star",
+    "subread": "featurecounts",
+    "trimgalore": "cutadapt",
+    "trim-galore": "cutadapt",
+    "trimmomatic": "trimmomatic",
+    "umicollapse": "umicollapse",
+    "umitools": "umitools",
+    "umi_tools": "umitools",
+}
+
+
+def multiqc_module(tool):
+    """Return the MultiQC module name for a tool or None if there is none
+
+    Parameters
+    ----------
+    tool : str
+        name of tool/conda package
+
+    Returns
+    -------
+    str or None
+    """
+    return MULTIQC_MODULES.get(str(tool).lower().replace("_", "").replace("-", "")) or MULTIQC_MODULES.get(str(tool).lower())
+
+
+def envs_from_config(config, steps):
+    """Collect conda environments of all tools configured to run
+
+    Parameters
+    ----------
+    config : dict
+        config json file parsed by snakemake.common.configfile
+    steps : list
+        list of workflow steps (e.g. ['QC', 'TRIMMING', 'MAPPING']) that will be run
+
+    Returns
+    -------
+    dict
+        environment name to set of workflow steps it is used in
+    """
+    logid = scriptname + ".envs_from_config: "
+    envs = dict()
+
+    for step in steps:
+        if not step or not config.get(step):
+            continue
+        conf = config[step]
+        if not isinstance(conf, dict):
+            continue
+        found = set()
+        stack = [conf]
+        while stack:
+            sub = stack.pop()
+            for key, val in sub.items():
+                if isinstance(val, dict):
+                    if key == "TOOLS":
+                        found.update(
+                            str(x) for x in val.keys() if x and str(x) != "None"
+                        )
+                    else:
+                        stack.append(val)
+                elif key.endswith("ENV") and isinstance(val, str) and val:
+                    found.add(str(val))
+        for env in found:
+            envs.setdefault(env, set()).add(step)
+
+    log.debug(logid + str(envs))
+    return envs
+
+
+def env_yaml(env, step, envdir):
+    """Find the conda env yaml belonging to an env name of a workflow step
+
+    Parameters
+    ----------
+    env : str
+        environment name as configured
+    step : str
+        workflow step the env is used in
+    envdir : str
+        directory holding the conda env yamls
+
+    Returns
+    -------
+    str or None
+        path to yaml file
+    """
+    for name in [env, "_".join([env, step]), "_".join([env, str(step).lower()])]:
+        path = os.path.join(envdir, name + ".yaml")
+        if os.path.isfile(path):
+            return path
+    return None
+
+
+def parse_env_yaml(yamlfile):
+    """Parse pinned versions from the dependencies of a conda env yaml
+
+    Parameters
+    ----------
+    yamlfile : str
+        path to conda env yaml
+
+    Returns
+    -------
+    dict
+        package name to version string, 'unpinned' if no version is defined
+    """
+    logid = scriptname + ".parse_env_yaml: "
+    versions = dict()
+    indeps = False
+
+    with open(yamlfile, "r") as y:
+        for line in y:
+            line = line.rstrip()
+            if not line or line.lstrip().startswith("#"):
+                continue
+            entry = line.strip()
+            if not entry.startswith("- "):
+                indeps = line.startswith("dependencies:")
+                continue
+            if not indeps:
+                continue
+            entry = entry[2:].strip()
+            if entry.endswith(":"):
+                continue
+            match = re.match(r"^([A-Za-z0-9._+-]+)\s*(.*)$", entry)
+            if not match:
+                continue
+            pkg, spec = match.group(1), match.group(2).strip()
+            if pkg.lower() in SKIP_PACKAGES:
+                continue
+            spec = re.sub(r"^[=]{1,2}\s*", "", spec)
+            versions[pkg] = spec if spec else "unpinned"
+
+    log.debug(logid + yamlfile + ": " + str(versions))
+    return versions
+
+
+# Package name prefixes of conda channels that are no part of the tool name
+PACKAGE_PREFIXES = ("bioconductor-", "r-", "python-", "perl-")
+
+# Tools always reported if part of an env, independent of the env name
+ALWAYS_REPORT = frozenset(["multiqc"])
+
+
+def _norm(name):
+    name = str(name).lower()
+    for prefix in PACKAGE_PREFIXES:
+        if name.startswith(prefix) and len(name) > len(prefix):
+            name = name[len(prefix) :]
+            break
+    return re.sub(r"[_\-.]", "", name)
+
+
+def relevant_packages(env, packages):
+    """Reduce the packages of an env to the tools worth reporting
+
+    Keeps the package the env is named after, plus every package MultiQC has a
+    module for, so dependencies like perl or matplotlib do not clutter the list.
+
+    Parameters
+    ----------
+    env : str
+        environment name as configured
+    packages : dict
+        package name to version as parsed from the env yaml
+
+    Returns
+    -------
+    dict
+        package name to version
+    """
+    keep = dict()
+    nenv = _norm(env)
+
+    for pkg, version in packages.items():
+        npkg = _norm(pkg)
+        if npkg == nenv or npkg.startswith(nenv) or nenv.startswith(npkg):
+            keep[pkg] = version
+        elif multiqc_module(pkg) or pkg.lower() in ALWAYS_REPORT:
+            keep[pkg] = version
+
+    return keep
+
+
+def collect_versions(config, steps, envdir):
+    """Collect versions of all tools configured to run
+
+    Parameters
+    ----------
+    config : dict
+        config json file parsed by snakemake.common.configfile
+    steps : list
+        list of workflow steps that will be run
+    envdir : str
+        directory holding the conda env yamls
+
+    Returns
+    -------
+    list
+        rows of [tool, version, multiqc module, steps] sorted by tool
+    """
+    logid = scriptname + ".collect_versions: "
+    tools = dict()
+
+    for env, envsteps in envs_from_config(config, steps).items():
+        yamlfile = None
+        for step in sorted(envsteps):
+            yamlfile = env_yaml(env, step, envdir)
+            if yamlfile:
+                break
+        if not yamlfile:
+            log.warning(
+                logid + "No conda env yaml found for " + str(env) + ", skipping version"
+            )
+            tools.setdefault(env, ["unknown", set()])[1].update(envsteps)
+            continue
+        packages = relevant_packages(env, parse_env_yaml(yamlfile))
+        if not packages:
+            log.warning(
+                logid
+                + "No version for "
+                + str(env)
+                + " deducible from "
+                + str(yamlfile)
+            )
+            packages = {env: "unknown"}
+        for pkg, version in packages.items():
+            tools.setdefault(pkg, [version, set()])
+            tools[pkg][0] = version
+            tools[pkg][1].update(envsteps)
+
+    rows = list()
+    for tool in sorted(tools):
+        version, envsteps = tools[tool]
+        rows.append(
+            [
+                tool,
+                version,
+                multiqc_module(tool) or "-",
+                ",".join(sorted(envsteps)),
+            ]
+        )
+
+    log.debug(logid + str(rows))
+    return rows
+
+
+def write_versions(config, steps, envdir, monsda_version, configfile=None, path=None):
+    """Write versions of all configured tools to LOGS/versions.txt
+
+    Parameters
+    ----------
+    config : dict
+        config json file parsed by snakemake.common.configfile
+    steps : list
+        list of workflow steps that will be run
+    envdir : str
+        directory holding the conda env yamls
+    monsda_version : str
+        version of MONSDA
+    configfile : str, optional
+        config file name to note in the header
+    path : str, optional
+        output file, by default LOGS/versions.txt
+
+    Returns
+    -------
+    str
+        path of the versions file
+    """
+    logid = scriptname + ".write_versions: "
+    path = path if path else os.path.join("LOGS", "versions.txt")
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+
+    if not os.path.isdir(envdir):
+        fallback = os.path.join(os.path.dirname(os.path.dirname(__file__)), "envs")
+        log.warning(
+            logid + str(envdir) + " not found, falling back to " + str(fallback)
+        )
+        envdir = fallback
+
+    rows = collect_versions(config, steps, envdir)
+
+    with open(path, "w") as out:
+        out.write(
+            "# MONSDA {v}\t{ts}\n".format(
+                v=monsda_version,
+                ts=datetime.datetime.now().strftime("%Y%m%d_%H_%M_%S"),
+            )
+        )
+        if configfile:
+            out.write("# config: {c}\n".format(c=str(configfile)))
+        out.write(
+            "# versions as pinned in the conda env yamls of the configured tools, not queried from the running binaries\n"
+        )
+        out.write("#tool\tversion\tmultiqc_module\tsteps\n")
+        for row in rows:
+            out.write("\t".join(row) + "\n")
+
+    log.info(logid + "Tool versions written to " + str(path))
+    return path
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
index e23a77a2..1c175928 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -67,7 +67,7 @@ process salmon_quant{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/salmon/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
@@ -123,7 +123,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/salmon/create_summary_snippet.log"
     }
     input:
     path de
@@ -143,7 +143,7 @@ process terminus_collapse{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/terminus/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
@@ -164,7 +164,7 @@ process salmon_idx{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/dexseq_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/dexseq/index.log"
         else if (filename == "dexseq.idx")            "${params.gDTUIDX}"
         else                                          "${params.gDTUUIDX}"
     }
@@ -193,7 +193,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_dexseq_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/DTU/dexseq/featurecount_dexseq_annotation.log"
     }
     output:
     path "*.gz", emit: anno
@@ -216,7 +216,7 @@ process run_dexseq{
         else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf(".html") > 0)      "DTU/${params.gSCOMBO}/DEXSeqReport_${params.gCOMBO}_${params.gDTUCOMP}/${file(filename).getName()}"
         else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_dexseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/dexseq/run_dexseq.log"
     }
     input:path counts
     path anno
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
index 26b82d59..7b1a24d8 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -67,7 +67,7 @@ process salmon_quant{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/salmon/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
@@ -123,7 +123,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/salmon/create_summary_snippet.log"
     }
     input:
     path de
@@ -143,7 +143,7 @@ process terminus_collapse{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/terminus/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
@@ -164,7 +164,7 @@ process salmon_idx{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/drimseq_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/drimseq/index.log"
         else if (filename == "drimseq.idx")           "${params.gDTUIDX}"
         else                                          "${params.gDTUUIDX}"
     }
@@ -193,7 +193,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_drimseq_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/DTU/drimseq/featurecount_drimseq_annotation.log"
     }
     output:
     path "*.gz", emit: anno
@@ -216,7 +216,7 @@ process run_drimseq{
         else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf(".html") > 0)      "DTU/${params.gSCOMBO}/drimseqReport_${params.gCOMBO}_${params.gDTUCOMP}/${file(filename).getName()}"
         else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_drimseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/drimseq/run_drimseq.log"
     }
     input:
     path counts
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
index ff4c6f10..accc5bdb 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -67,7 +67,7 @@ process salmon_quant{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/salmon/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/salmon/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/salmon/${params.gCONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
     input:
@@ -123,7 +123,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${params.gSCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/salmon/create_summary_snippet.log"
     }
     input:
     path de
@@ -143,7 +143,7 @@ process terminus_collapse{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/terminus/${params.gCONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/DTU/terminus/${file(filename).getName()}"
         else                                    "DTU/${params.gSCOMBO}/terminus/${file(filename).getName()}"
     }
     input:
@@ -164,7 +164,7 @@ process salmon_idx{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/spit_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${params.gCOMBO}/${params.gCONDITION}/DTU/spit/index.log"
         else if (filename == "spit.idx")           "${params.gDTUIDX}"
         else                                          "${params.gDTUUIDX}"
     }
@@ -193,7 +193,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${params.gSCOMBO}/featurecount_spit_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/DTU/spit/featurecount_spit_annotation.log"
     }
     output:
     path "*.gz", emit: anno
@@ -215,7 +215,7 @@ process run_spit{
         if (filename.indexOf("_table") > 0)      "DTU/${params.gSCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DTU/${params.gSCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf("SESSION") > 0)      "DTU/${params.gSCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${params.gSCOMBO}/run_spit.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${params.gSCOMBO}/DTU/spit/run_spit.log"
     }
     input:
     path counts
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
index 947ad664..67c46693 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -327,7 +327,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/DTU/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -338,8 +338,8 @@ rule salmon_index:
     shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -348,7 +348,7 @@ if paired == 'paired':
         shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -361,7 +361,7 @@ if paired == 'paired':
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -377,7 +377,7 @@ else:
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -390,7 +390,7 @@ if runterminus:
     rule terminus_group:
         input:  ctsdir = rules.mapping.output.ctsdir
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -401,7 +401,7 @@ if runterminus:
         input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
                 dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        log:    expand("LOGS/{combo}/DTU/salmon/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -413,7 +413,7 @@ else:
 rule create_annotation_table:
     input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/salmon/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
@@ -424,7 +424,7 @@ rule run_DTU:
     input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
     output: session = expand(rules.themall.input.session, combo=combo, scombo=scombo),
             res = rules.themall.input.res
-    log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
+    log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1  # Due to BPPARAM errors, else int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -442,7 +442,7 @@ rule run_DTU:
 #     output: sig   = rules.themall.input.sig,
 #             sig_d = rules.themall.input.sig_d,
 #             sig_u = rules.themall.input.sig_u
-#     log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
+#     log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
 #     conda:  "<REPO>/envs/"+DTUENV+".yaml"
 #     threads: 1
 #     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
@@ -455,7 +455,7 @@ rule create_summary_snippet:
             # rules.filter_significant.output.sig_d,
             # rules.filter_significant.output.sig_u,
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/dexseq/create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index ad06027f..ffd3dcf4 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -337,7 +337,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/DTU/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -348,8 +348,8 @@ rule salmon_index:
     shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -358,7 +358,7 @@ if paired == 'paired':
         shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -371,7 +371,7 @@ if paired == 'paired':
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -387,7 +387,7 @@ else:
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -400,7 +400,7 @@ if runterminus:
     rule terminus_group:
         input:  ctsdir = rules.mapping.output.ctsdir
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -411,7 +411,7 @@ if runterminus:
         input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
                 dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        log:    expand("LOGS/{combo}/DTU/salmon/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -423,7 +423,7 @@ else:
 rule create_annotation_table:
     input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/salmon/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
@@ -441,7 +441,7 @@ rule run_DTU:
             fig_P   = rules.themall.input.fig_P,
             fig_PV  = rules.themall.input.fig_PV,
             fig_files = rules.themall.input.fig_files
-    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/drimseq/run_DTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -461,7 +461,7 @@ rule filter_significant_drimseq:
             sig_t   = rules.themall.input.sig_t,
             sig_dt  = rules.themall.input.sig_dt,
             sig_ut  = rules.themall.input.sig_ut
-    log:    "LOGS/DTU/filter_drimseqDTU.log"
+    log:    expand("LOGS/{combo}/DTU/drimseq/filter_drimseqDTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
@@ -484,7 +484,7 @@ rule create_summary_snippet:
             rules.themall.input.sig_ut,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/drimseq/create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index 67bd4175..26d803c1 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -334,7 +334,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/DTU/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -345,8 +345,8 @@ rule salmon_index:
     shell:  "set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}"
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -355,7 +355,7 @@ if paired == 'paired':
         shell:  "ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}"
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -368,7 +368,7 @@ if paired == 'paired':
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -384,7 +384,7 @@ else:
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  "<REPO>/envs/"+COUNTENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -397,7 +397,7 @@ if runterminus:
     rule terminus_group:
         input:  ctsdir = rules.mapping.output.ctsdir
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/terminus_group.log"
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -408,7 +408,7 @@ if runterminus:
         input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
                 dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        log:    expand("LOGS/{combo}/DTU/salmon/terminus_collapse.log", combo=combo)
         conda:  "<REPO>/envs/"+TERMINUSENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TERMINUSENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -420,7 +420,7 @@ else:
 rule create_annotation_table:
     input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/salmon/create_DTU_table.log", combo=combo)
     conda:  "<REPO>/envs/"+COUNTENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+COUNTENV+""+"-VERSION"
     threads: 1
@@ -435,7 +435,7 @@ rule run_DTU:
             res_i   = rules.themall.input.res_i,
             fig_PV  = rules.themall.input.fig_PV,
             fig_W   = rules.themall.input.fig_W
-    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/spit/run_DTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -455,7 +455,7 @@ rule filter_significant_spit:
             sig_t   = rules.themall.input.sig_t,
             sig_dt  = rules.themall.input.sig_dt,
             sig_ut  = rules.themall.input.sig_ut
-    log:    "LOGS/DTU/filter_spitDTU.log"
+    log:    expand("LOGS/{combo}/DTU/spit/filter_spitDTU.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
@@ -476,7 +476,7 @@ rule create_summary_snippet:
             rules.themall.input.sig_ut,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/spit/create_summary_snippet.log", combo=combo)
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index b4b5c483..d6b5168a 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -54,7 +54,7 @@ process starfusion{
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
         else      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
     }
     input:
diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index c9cdade3..2acc1d57 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -325,7 +325,7 @@ rule generate_ctat_lib:
     output: lib = directory(CTATLIB),
             tmpfa = temp(expand("TMP/{fenv}/ctat_ref.fa", fenv=FENV)),
             tmpanno = temp(expand("TMP/{fenv}/ctat_ref.gtf", fenv=FENV))
-    log:    expand("LOGS/{sets}/{fenv}.ctat.log", sets=SETS, fenv=FENV)
+    log:    expand("LOGS/{sets}/FUSIONS/{fenv}/ctat.log", sets=SETS, fenv=FENV)
     conda:  "<REPO>/envs/"+FENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -343,7 +343,7 @@ if not fastqmode:
         output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                 abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv",
                 normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction"
-        log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+        log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
         conda:  "<REPO>/envs/"+FENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -358,7 +358,7 @@ else:
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
-            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
-            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
             conda:  "<REPO>/envs/"+FENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+FENV+""+"-VERSION"
             threads: MAXTHREAD
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index e73fc484..968aad26 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -180,7 +180,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/bbduk/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -235,10 +235,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -291,7 +292,7 @@ process bwa_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "bwa.idx")                          "${params.gMAPIDX}"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/index.log"
         else                                                "${params.gMAPUIDX}"
     }
     input:
@@ -314,7 +315,7 @@ process bwa_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/${file(filename).getName()}"
         else null
     }
     input:
@@ -400,7 +401,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -425,7 +426,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -455,7 +456,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -506,27 +507,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index 3c28a4c2..1d4806c1 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/bbduk/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -234,10 +234,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -289,7 +290,7 @@ process rustar_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -316,8 +317,8 @@ process rustar_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -431,7 +432,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -456,7 +457,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -486,7 +487,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -537,27 +538,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 6b04277b..19c5c75f 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/bbduk/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -234,10 +234,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -289,7 +290,7 @@ process star_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -304,7 +305,7 @@ process star_idx{
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && rm -rf STARTMP && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
@@ -316,8 +317,8 @@ process star_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -431,7 +432,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -456,7 +457,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -486,7 +487,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -537,27 +538,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index 16ec885b..7032e3e9 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -180,7 +180,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/cutadapt/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -235,10 +235,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -291,7 +292,7 @@ process bwa_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "bwa.idx")                          "${params.gMAPIDX}"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/index.log"
         else                                                "${params.gMAPUIDX}"
     }
     input:
@@ -314,7 +315,7 @@ process bwa_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/${file(filename).getName()}"
         else null
     }
     input:
@@ -400,7 +401,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -425,7 +426,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -455,7 +456,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -506,27 +507,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index 0b3ec7f9..dd066640 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/cutadapt/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -234,10 +234,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -289,7 +290,7 @@ process rustar_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -316,8 +317,8 @@ process rustar_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -431,7 +432,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -456,7 +457,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -486,7 +487,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -537,27 +538,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index e1730c77..7161a718 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/cutadapt/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -234,10 +234,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -289,7 +290,7 @@ process star_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -304,7 +305,7 @@ process star_idx{
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && rm -rf STARTMP && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
@@ -316,8 +317,8 @@ process star_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -431,7 +432,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -456,7 +457,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -486,7 +487,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -537,27 +538,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index debcf88b..efe016fa 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -180,7 +180,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/trimgalore/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -230,10 +230,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -286,7 +287,7 @@ process bwa_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "bwa.idx")                          "${params.gMAPIDX}"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/bwa_index.log"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/index.log"
         else                                                "${params.gMAPUIDX}"
     }
     input:
@@ -309,7 +310,7 @@ process bwa_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/bwa/${file(filename).getName()}"
         else null
     }
     input:
@@ -395,7 +396,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -420,7 +421,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -450,7 +451,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -501,27 +502,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index 72617cd9..50a71593 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/trimgalore/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -229,10 +229,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -284,7 +285,7 @@ process rustar_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/rustar_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -311,8 +312,8 @@ process rustar_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -426,7 +427,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -451,7 +452,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -481,7 +482,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -532,27 +533,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index 824d8c7e..d4b671df 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -179,7 +179,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${params.gCOMBO}/${params.gCONDITION}/TRIMMING/trimgalore/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -229,10 +229,11 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
         else null
     }
+    publishDir "${workflow.workDir}/../LOGS/${params.gCOMBO}/${params.gCONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
     input:
     path todedup
     path bami
@@ -284,7 +285,7 @@ process star_idx{
     label 'big_mem'
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/star_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/index.log"
         else if (filename.indexOf(".idx") > 0)           "${params.gMAPIDX}"
         else                                             "${params.gMAPUIDX}"
     }
@@ -299,7 +300,7 @@ process star_idx{
     gen =  genome.getName()
     an  = anno.getName()
     """
-    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p ${params.gMAPUIDXNAME} && rm -rf STARTMP && ${params.gMAPBIN} ${params.gIDXPARAMS} --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir ${params.gMAPUIDXNAME} --genomeFastaFiles tmp.fa && touch ${params.gMAPUIDXNAME} && ln -s ${params.gMAPUIDXNAME} star.idx && rm -f tmp.fa tmp_anno && ln -fs ${params.gMAPUIDXNAME}/* . && rm -rf STARTMP
     """
 }
 process star_mapping{
@@ -311,8 +312,8 @@ process star_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/star/"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
         else                                         "MAPPED/${params.gCOMBO}/${params.gCONDITION}/"+"${filename}"
     }
@@ -426,7 +427,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -451,7 +452,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -481,7 +482,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${params.gCOMBO}/${params.gCONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${params.gCOMBO}/${params.gCONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
     input:
@@ -532,27 +533,31 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
+    mkdir -p "\$COLLECT"
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
+    fi
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
     fi
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index e334d81a..05f825f9 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -437,7 +437,7 @@ else:
     rule bbduk_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
@@ -481,7 +481,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
@@ -501,7 +501,7 @@ if bwaalg == 'mem':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -516,7 +516,7 @@ if bwaalg == 'mem':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -535,7 +535,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -553,7 +553,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -566,7 +566,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
             output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -582,7 +582,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -595,7 +595,7 @@ elif bwaalg == 'samse':
         output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -613,7 +613,7 @@ elif bwaalg == 'sampe':
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -630,7 +630,7 @@ elif bwaalg == 'bwasw':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -643,7 +643,7 @@ elif bwaalg == 'bwasw':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -657,7 +657,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -669,7 +669,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -679,7 +679,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -690,7 +690,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -712,16 +712,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -732,16 +733,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -754,16 +756,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -774,16 +777,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -792,16 +796,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -809,16 +814,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
index 3ff2e8f1..9d6e2fb7 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -437,7 +437,7 @@ else:
     rule bbduk_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -484,7 +484,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -504,10 +504,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -526,10 +526,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -549,10 +549,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -572,7 +572,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -584,7 +584,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -594,7 +594,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -605,7 +605,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -627,16 +627,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -647,16 +648,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -669,16 +671,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -689,16 +692,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -707,16 +711,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -724,16 +729,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index fb34a212..f7fbcf26 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -437,7 +437,7 @@ else:
     rule bbduk_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -482,9 +482,9 @@ rule generate_index:
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
-            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
-            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+            tmpfa = temp(expand("TMP/{mape}_{unikey}/ref.fa", mape=MAPPERENV, unikey=unik)),
+            tmpref = temp(expand("TMP/{mape}_{unikey}/ref.anno", mape=MAPPERENV, unikey=unik))
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -492,8 +492,9 @@ rule generate_index:
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
             anno = ANNOTATION,                        
             pref = PREFIX,
-            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0])),
+            stmp = expand("TMP/{mape}_{unikey}/generate_index", mape=MAPPERENV, unikey=unik)[0]
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf {params.stmp} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir {params.stmp} --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf {params.stmp}"
 if paired == 'paired':
     rule mapping:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
@@ -504,10 +505,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -526,10 +527,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -549,10 +550,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -572,7 +573,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -584,7 +585,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -594,7 +595,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -605,7 +606,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -627,16 +628,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -647,16 +649,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -669,16 +672,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -689,16 +693,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -707,16 +712,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -724,16 +730,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index b0e23530..dde91676 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -437,7 +437,7 @@ else:
     rule cutadapt_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
@@ -481,7 +481,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
@@ -501,7 +501,7 @@ if bwaalg == 'mem':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -516,7 +516,7 @@ if bwaalg == 'mem':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -535,7 +535,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -553,7 +553,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -566,7 +566,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
             output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -582,7 +582,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -595,7 +595,7 @@ elif bwaalg == 'samse':
         output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -613,7 +613,7 @@ elif bwaalg == 'sampe':
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -630,7 +630,7 @@ elif bwaalg == 'bwasw':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -643,7 +643,7 @@ elif bwaalg == 'bwasw':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -657,7 +657,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -669,7 +669,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -679,7 +679,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -690,7 +690,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -712,16 +712,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -732,16 +733,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -754,16 +756,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -774,16 +777,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -792,16 +796,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -809,16 +814,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
index d2ae0794..3b1f67b5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -437,7 +437,7 @@ else:
     rule cutadapt_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -484,7 +484,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -504,10 +504,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -526,10 +526,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -549,10 +549,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -572,7 +572,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -584,7 +584,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -594,7 +594,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -605,7 +605,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -627,16 +627,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -647,16 +648,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -669,16 +671,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -689,16 +692,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -707,16 +711,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -724,16 +729,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index a26b5994..a7dfcc3e 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -416,7 +416,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -437,7 +437,7 @@ else:
     rule cutadapt_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -461,7 +461,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -469,7 +469,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -482,9 +482,9 @@ rule generate_index:
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
-            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
-            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+            tmpfa = temp(expand("TMP/{mape}_{unikey}/ref.fa", mape=MAPPERENV, unikey=unik)),
+            tmpref = temp(expand("TMP/{mape}_{unikey}/ref.anno", mape=MAPPERENV, unikey=unik))
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -492,8 +492,9 @@ rule generate_index:
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
             anno = ANNOTATION,                        
             pref = PREFIX,
-            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0])),
+            stmp = expand("TMP/{mape}_{unikey}/generate_index", mape=MAPPERENV, unikey=unik)[0]
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf {params.stmp} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir {params.stmp} --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf {params.stmp}"
 if paired == 'paired':
     rule mapping:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
@@ -504,10 +505,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -526,10 +527,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -549,10 +550,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -572,7 +573,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -584,7 +585,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -594,7 +595,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -605,7 +606,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -627,16 +628,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -647,16 +649,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -669,16 +672,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -689,16 +693,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -707,16 +712,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -724,16 +730,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index abf5ebd1..cdccc5b4 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -423,7 +423,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:   "LOGS/{combo}/{file}_trim.log"
+        log:   "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -444,7 +444,7 @@ else:
     rule trimgalore_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -468,7 +468,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -476,7 +476,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, "MAPPING", MAPPERENV)["OPTIONS"],["INDEX"],)
@@ -488,7 +488,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: 1
@@ -508,7 +508,7 @@ if bwaalg == 'mem':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -523,7 +523,7 @@ if bwaalg == 'mem':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -542,7 +542,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -560,7 +560,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -573,7 +573,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
             output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -589,7 +589,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda: "<REPO>/envs/"+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -602,7 +602,7 @@ elif bwaalg == 'samse':
         output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -620,7 +620,7 @@ elif bwaalg == 'sampe':
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -637,7 +637,7 @@ elif bwaalg == 'bwasw':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -650,7 +650,7 @@ elif bwaalg == 'bwasw':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -664,7 +664,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -676,7 +676,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -686,7 +686,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -697,7 +697,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -719,16 +719,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -739,16 +740,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -761,16 +763,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -781,16 +784,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -799,16 +803,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -816,16 +821,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
index 476addd5..f83f9432 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -423,7 +423,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:   "LOGS/{combo}/{file}_trim.log"
+        log:   "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -444,7 +444,7 @@ else:
     rule trimgalore_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -468,7 +468,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -476,7 +476,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -491,7 +491,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -511,10 +511,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -533,10 +533,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -556,10 +556,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -579,7 +579,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -591,7 +591,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -601,7 +601,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -612,7 +612,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -634,16 +634,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -654,16 +655,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -676,16 +678,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -696,16 +699,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -714,16 +718,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -731,16 +736,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 4a1f5cad..174dcaa3 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -310,7 +310,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -320,7 +320,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -330,7 +330,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -341,7 +341,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -351,7 +351,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -361,7 +361,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda: "<REPO>/envs/"+QCENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -371,7 +371,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -381,7 +381,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -391,7 +391,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -401,7 +401,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda: "<REPO>/envs/"+QCENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+QCENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -423,7 +423,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:   "LOGS/{combo}/{file}_trim.log"
+        log:   "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -444,7 +444,7 @@ else:
     rule trimgalore_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: "<REPO>/envs/"+TRIMENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+TRIMENV+""+"-VERSION"
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -468,7 +468,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda: "<REPO>/envs/"+DEDUPENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DEDUPENV+""+"-VERSION"
     threads: 1
@@ -476,7 +476,7 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
 
 MAPPERBIN, MAPPERENV = env_bin_from_config(config,'MAPPING')
 keydict = sub_dict(tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'], ['INDEX'])
@@ -489,9 +489,9 @@ rule generate_index:
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
-            tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
-            tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+            tmpfa = temp(expand("TMP/{mape}_{unikey}/ref.fa", mape=MAPPERENV, unikey=unik)),
+            tmpref = temp(expand("TMP/{mape}_{unikey}/ref.anno", mape=MAPPERENV, unikey=unik))
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda: "<REPO>/envs/"+MAPPERENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
     threads: MAXTHREAD
@@ -499,8 +499,9 @@ rule generate_index:
             ipara = lambda w,output: fixRunParameters(config, MAPPERENV, SAMPLES[0], None, 'MAPPING', 'INDEX', "--sjdbGTFfile", f"--sjdbGTFfile {output.tmpref}"),
             anno = ANNOTATION,                        
             pref = PREFIX,
-            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0]))
-    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/star_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/star_generate_index"
+            lnkidx = lambda wildcards, output: str(os.path.abspath(output.uidx[0])),
+            stmp = expand("TMP/{mape}_{unikey}/generate_index", mape=MAPPERENV, unikey=unik)[0]
+    shell:  "if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf {params.stmp} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir {params.stmp} --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf {params.stmp}"
 if paired == 'paired':
     rule mapping:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
@@ -511,10 +512,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
         container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
         threads: MAXTHREAD
@@ -533,10 +534,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -556,10 +557,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
             container: "oras://ghcr.io/jfallmann/monsda:"+MAPPERENV+""+"-VERSION"
             threads: MAXTHREAD
@@ -579,7 +580,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -591,7 +592,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -601,7 +602,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -612,7 +613,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda: "<REPO>/envs/samtools.yaml"
     container: "oras://ghcr.io/jfallmann/monsda:samtools"+"-VERSION"
     threads: MAXTHREAD
@@ -634,16 +635,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -654,16 +656,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -676,16 +679,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -696,16 +700,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -714,16 +719,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -731,16 +737,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/workflows/alevinfry.nf b/workflows/alevinfry.nf
index 6bbc9efd..957f1215 100644
--- a/workflows/alevinfry.nf
+++ b/workflows/alevinfry.nf
@@ -36,7 +36,7 @@ process alevinfry_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/alevinfry/${file(filename).getName()}"
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/alevinfry.smk b/workflows/alevinfry.smk
index ee91fcd7..520d47eb 100644
--- a/workflows/alevinfry.smk
+++ b/workflows/alevinfry.smk
@@ -11,7 +11,7 @@ rule themall:
 rule generate_t2g:
     input:  anno = ANNOTATION
     output: t2g = expand("{refd}/INDICES/{cenv}_{unikey}/t2g.tsv", refd=REFDIR, cenv=COUNTENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{cenv}.t2g.log", sets=SETS, cenv=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cenv}/t2g.log", sets=SETS, cenv=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: 1
@@ -23,7 +23,7 @@ rule counting:
             t2g = rules.generate_t2g.output.t2g
     output: cnts = report("COUNTS/{combo}/{file}/alevin/quants_mat.mtx.gz", category="COUNTING"),
             ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-    log:    "LOGS/{combo}/{file}/alevinfryquant.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/alevinfry/alevinfryquant.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
diff --git a/workflows/annotatebed.smk b/workflows/annotatebed.smk
index a76e0d71..2da2c527 100644
--- a/workflows/annotatebed.smk
+++ b/workflows/annotatebed.smk
@@ -12,7 +12,7 @@ if all(checklist):
     rule BamToBed:
         input:  "TRACKS/{combo}/{file}_mapped_{type}.bed.gz"
         output: "BED/{combo}/{file}_mapped_{type}.bed.gz"
-        log:    "LOGS/Bed/linkbed{file}_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/bedtools/linkbed{type}.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -22,7 +22,7 @@ elif all(checklist2):
     rule BamToBed:
         input:  "PEAKS/{combo}/{file}_mapped_{type}.bed.gz"
         output: "BED/{combo}/{file}_mapped_{type}.bed.gz"
-        log:    "LOGS/Bed/linkbed{file}_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/bedtools/linkbed{type}.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -35,7 +35,7 @@ else:
                     "MAPPED/{combo}/{file}_mapped_sorted_unique.bam"
             output: "BED/{combo}/{file}_mapped_sorted.bed.gz",
                     "BED/{combo}/{file}_mapped_unique.bed.gz"
-            log:    "LOGS/Bed/createbed{file}.log"
+            log:    "LOGS/{combo}/{file}/PEAKS/bedtools/createbed.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -47,7 +47,7 @@ else:
                     "MAPPED/{combo}/{file}_mapped_sorted_unique.bam"
             output: "BED/{combo}/{file}_mapped_sorted.bed.gz",
                     "BED/{combo}/{file}_mapped_unique.bed.gz"
-            log:    "LOGS/Bed/createbed{file}.log"
+            log:    "LOGS/{combo}/{file}/PEAKS/bedtools/createbed.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -56,7 +56,7 @@ else:
 rule AnnotateBed:
     input:  rules.BamToBed.output
     output: "BED/{combo}/{file}_anno_{type}.bed.gz"
-    log:    "LOGS/Bed/annobeds_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/bedtools/annobeds_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -71,7 +71,7 @@ rule UnzipGenome:
     output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
-    log:    expand("LOGS/PEAKS/{combo}/indexfa.log", combo=combo)
+    log:    expand("LOGS/{combo}/PEAKS/bedtools/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
@@ -83,7 +83,7 @@ rule UnzipGenome_no_us:
     output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
-    log:    expand("LOGS/PEAKS/{combo}/indexfa.log", combo=combo)
+    log:    expand("LOGS/{combo}/PEAKS/bedtools/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
@@ -97,7 +97,7 @@ rule AddSequenceToBed:
     output: bed = "BED/{combo}/{file}_anno_seq_{type}.bed.gz",
             bt = temp("BED/{combo}/{file}_bed_chr_{type}.tmp"),
             bs = temp("BED/{combo}/{file}_bed_seq_{type}.tmp")
-    log:    "LOGS/BED/seq2bed{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/bedtools/seq2bed{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -108,7 +108,7 @@ rule AddSequenceToBed:
 rule MergeAnnoBed:
     input:  rules.AddSequenceToBed.output
     output: "BED/{combo}/{file}_anno_seq_{type}_merged.bed.gz"
-    log:    "LOGS/Bed/mergebeds_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/bedtools/mergebeds_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
diff --git a/workflows/bbduk.nf b/workflows/bbduk.nf
index 2a941a98..6dcfb261 100644
--- a/workflows/bbduk.nf
+++ b/workflows/bbduk.nf
@@ -15,7 +15,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/bbduk/${file(filename).getSimpleName()}.log"
         else null
     }
 
diff --git a/workflows/bbduk.smk b/workflows/bbduk.smk
index c47371bb..63b3bd31 100644
--- a/workflows/bbduk.smk
+++ b/workflows/bbduk.smk
@@ -6,7 +6,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: MAXTHREAD
@@ -28,7 +28,7 @@ else:
     rule bbduk_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/bbduk/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: MAXTHREAD
diff --git a/workflows/bwa.nf b/workflows/bwa.nf
index e436f6f0..9db047a6 100644
--- a/workflows/bwa.nf
+++ b/workflows/bwa.nf
@@ -41,7 +41,7 @@ process bwa_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "bwa.idx")                          "$MAPIDX"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa_index.log"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/MAPPING/bwa/index.log"
         else                                                "$MAPUIDX"
     }
 
@@ -72,7 +72,7 @@ process bwa_mapping{
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/_trimmed/,"")}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/bwa/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/bwa.smk b/workflows/bwa.smk
index 04368eaf..8bfebc92 100644
--- a/workflows/bwa.smk
+++ b/workflows/bwa.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: 1
@@ -31,7 +31,7 @@ if bwaalg == 'mem':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -47,7 +47,7 @@ if bwaalg == 'mem':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -67,7 +67,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -85,7 +85,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #                    sai2 = report("MAPPED/{combo}/{file}_mapped.R2.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda:  ""+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -99,7 +99,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
             output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                     mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -115,7 +115,7 @@ elif bwaalg == 'aln': # not supported as stand alone as we need mappign files to
 #            output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
 #                    mapped = "UNMAPPED/{combo}/{file}_mapped.sam",
 #                    unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-#            log:    "LOGS/{combo}/{file}/mapping.log"
+#            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
 #            conda:  ""+MAPPERENV+".yaml"
 #            threads: MAXTHREAD
 #            params: mpara = lambda wildcards: ' '.join("{!s} {!s}".format(key, val) for (key, val) in tool_params(wildcards.file, None, config, 'MAPPING')['OPTIONS'][1].items()),
@@ -129,7 +129,7 @@ elif bwaalg == 'samse':
         output: sai = report("MAPPED/{combo}/{file}_mapped.sai", category="MAPPING"),
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -148,7 +148,7 @@ elif bwaalg == 'sampe':
                 mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -166,7 +166,7 @@ elif bwaalg == 'bwasw':
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -180,7 +180,7 @@ elif bwaalg == 'bwasw':
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/bwa/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
diff --git a/workflows/bwa2.nf b/workflows/bwa2.nf
index 8bd1ea33..e7ccd535 100644
--- a/workflows/bwa2.nf
+++ b/workflows/bwa2.nf
@@ -41,7 +41,7 @@ process bwa2_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "bwa2.idx")                          "$MAPIDX"
-        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/bwa2_index.log"
+        else if (filename.indexOf("Log.out") > 0)           "LOGS/${COMBO}/${CONDITION}/MAPPING/bwa2/index.log"
         else                                                "$MAPUIDX"
     }
 
@@ -72,7 +72,7 @@ process bwa2_mapping{
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/_trimmed/,"")}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/bwa2/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/bwa2.smk b/workflows/bwa2.smk
index c566a7f7..79bbb9e6 100644
--- a/workflows/bwa2.smk
+++ b/workflows/bwa2.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: 1
@@ -28,7 +28,7 @@ if paired == 'paired':
 		output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
 				unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
 				unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-		log:    "LOGS/{combo}/{file}/mapping.log"
+		log:    "LOGS/{combo}/{file}/MAPPING/bwa2/mapping.log"
 		conda:  ""+MAPPERENV+".yaml"
 		container: "oras://jfallmann/monsda:"+MAPPERENV+""
 		threads: MAXTHREAD
@@ -44,7 +44,7 @@ else:
 				ref = REFERENCE
 		output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
 				unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-		log:    "LOGS/{combo}/{file}/mapping.log"
+		log:    "LOGS/{combo}/{file}/MAPPING/bwa2/mapping.log"
 		conda:  ""+MAPPERENV+".yaml"
 		container: "oras://jfallmann/monsda:"+MAPPERENV+""
 		threads: MAXTHREAD
diff --git a/workflows/bwameth.nf b/workflows/bwameth.nf
index 0527d17f..ffe845d7 100644
--- a/workflows/bwameth.nf
+++ b/workflows/bwameth.nf
@@ -40,7 +40,7 @@ process bwameth_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/bwameth_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/bwameth/index.log"
         else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
         else                                             "$MAPUIDX"
     }
@@ -74,7 +74,7 @@ process bwameth_mapping{
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/_trimmed/,"")}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/bwameth/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/bwameth.smk b/workflows/bwameth.smk
index ba6955c0..ab6e3034 100644
--- a/workflows/bwameth.smk
+++ b/workflows/bwameth.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  ref = REFERENCE
     output: idx = directory(INDEX),
             uidx = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX+os.path.basename(REFERENCE).replace(".gz", ""))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: 1
@@ -26,7 +26,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/bwameth.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwameth/bwameth.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ else:
                 uidx = rules.generate_index.output.uidx[0],
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/bwameth/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/ciri2.nf b/workflows/ciri2.nf
index 4652ff4d..7927582b 100644
--- a/workflows/ciri2.nf
+++ b/workflows/ciri2.nf
@@ -18,7 +18,7 @@ process ciri2{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_circs") > 0)      "CIRCS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"        
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/CIRCS/ciri2/${file(filename).getSimpleName()}"
     }
 
     input:
diff --git a/workflows/ciri2.smk b/workflows/ciri2.smk
index 0d1de62c..34d21250 100644
--- a/workflows/ciri2.smk
+++ b/workflows/ciri2.smk
@@ -19,7 +19,7 @@ rule FindCircs:
             ts = temp("CIRCS/{combo}/{file}_tmp.sam"),
             ta = temp("CIRCS/{combo}/{file}_tmp.gtf"),
             tf = temp("CIRCS/{combo}/{file}_tmp.fa")
-    log:    "LOGS/CIRCS/{combo}/{file}_ciri2.log"
+    log:    "LOGS/{combo}/{file}/CIRCS/ciri2/ciri2.log"
     conda:  ""+CENV+".yaml"
     container: "oras://jfallmann/monsda:"+CENV+""
     threads: MAXTHREAD
diff --git a/workflows/collect.nf b/workflows/collect.nf
index 1099a1b4..47459e3a 100644
--- a/workflows/collect.nf
+++ b/workflows/collect.nf
@@ -5,7 +5,7 @@ process collect_stuff{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->        
-        "LOGS/COLLECT/${COMBO}/${CONDITION}/${file(filename).getName()}"
+        "LOGS/${COMBO}/${CONDITION}/COLLECT/collect/${file(filename).getName()}"
     }
     input:
     path check
diff --git a/workflows/countreads.nf b/workflows/countreads.nf
index 8da0acda..e800a5d7 100644
--- a/workflows/countreads.nf
+++ b/workflows/countreads.nf
@@ -25,7 +25,7 @@ process count_fastq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".count") > 0)      "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.count"   
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/countfastq.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/COUNTING/countreads/countfastq.log"
     }
 
     input:
@@ -68,7 +68,7 @@ process count_trimmed_fastq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".count") > 0)      "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.count"   
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/count_trimmedreads.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/COUNTING/countreads/count_trimmedreads.log"
     }
 
     input:
@@ -111,7 +111,7 @@ process count_dedup_fastq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".count") > 0)      "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.count"   
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/count_dedupreads.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/COUNTING/countreads/count_dedupreads.log"
     }
 
     input:
@@ -155,7 +155,7 @@ process count_mappers{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".count") > 0)      "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.count"        
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/count_mappers.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/COUNTING/countreads/count_mappers.log"
 
     }
 
@@ -187,10 +187,12 @@ process featurecount{
     saveAs: {filename ->
         if (filename.indexOf(".count") > 0)      "COUNTS/Featurecounts_${FEAT}s/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.counts.gz"        
         else if (filename.indexOf(".summary") > 0)      "COUNTS/Featurecounts_${FEAT}s/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}.counts.summary"        
-        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/featurecount_${FEAT}s.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/COUNTING/countreads/featurecount_${FEAT}s.log"
 
     }
 
+    publishDir "${workflow.workDir}/../LOGS/${SCOMBO}/${CONDITION}/COUNTING/countreads" , mode: 'copy', pattern: "*.summary"
+
     input:
     path fls
 
@@ -238,7 +240,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DE/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DE/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DE/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DE/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DE/countreads/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -269,7 +271,7 @@ process summarize_counts{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename == "summary")      "COUNTS/${SCOMBO}/${CONDITION}/summary"
-        else if (filename == "log")        "LOGS/${SCOMBO}/${CONDITION}/summarize_counts.log"
+        else if (filename == "log")        "LOGS/${SCOMBO}/${CONDITION}/COUNTING/countreads/summarize_counts.log"
     }
 
     input:
diff --git a/workflows/countreads.smk b/workflows/countreads.smk
index 6a3ab701..8e149b1f 100644
--- a/workflows/countreads.smk
+++ b/workflows/countreads.smk
@@ -34,7 +34,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
         output: r1 = "COUNTS/{combo}/{file}_R1_raw_fq.count",
                 r2 = "COUNTS/{combo}/{file}_R2_raw_fq.count"
-        log:    "LOGS/{combo}/{file}/countfastq.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/countfastq.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -45,7 +45,7 @@ if paired == 'paired':
                 r2 = expand("TRIMMED_FASTQ/{combo}/{{file}}_R2_trimmed.fastq.gz", combo=scombo)
         output: r1 = "COUNTS/{combo}/{file}_R1_trimmed_fq.count",
                 r2 = "COUNTS/{combo}/{file}_R2_trimmed_fq.count"
-        log:    "LOGS/{combo}/{file}/countfastq.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/countfastq.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -55,7 +55,7 @@ else:
     rule count_fastq:
         input:  r1 = lambda wildcards: expand("FASTQ/{rawfile}.fastq.gz", rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
         output: r1 = "COUNTS/{combo}/{file}_raw_fq.count"
-        log:    "LOGS/{combo}/{file}/countfastq.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/countfastq.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -64,7 +64,7 @@ else:
     rule count_trimmed_fastq:
         input:  r1 = expand("TRIMMED_FASTQ/{combo}/{{file}}_trimmed.fastq.gz", combo=scombo)
         output: r1 = "COUNTS/{combo}/{file}_trimmed_fq.count"
-        log:    "LOGS/{combo}/{file}/count_trimmedfastq.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/count_trimmedfastq.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -73,7 +73,7 @@ else:
 rule count_mappers:
     input:  m = expand("MAPPED/{combo}/{{file}}_mapped_sorted.bam", combo=scombo)
     output: m = "COUNTS/{combo}/{file}_mapped.count"
-    log:    "LOGS/{combo}/{file}/countmappers.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/countmappers.log"
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -83,7 +83,7 @@ rule count_mappers:
 rule count_unique_mappers:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique.bam", combo=scombo)
     output: u = "COUNTS/{combo}/{file}_mapped_unique.count"
-    log:    "LOGS/{combo}/{file}/count_unique_mappers.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/count_unique_mappers.log"
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -93,7 +93,7 @@ rule count_unique_mappers:
 rule count_dedup_mappers:
     input:  m = expand("MAPPED/{combo}/{{file}}_mapped_sorted_dedup.bam", combo=scombo)
     output: m = "COUNTS/{combo}/{file}_mapped_dedup.count"
-    log:    "LOGS/{combo}/{file}/countdedupmappers.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/countdedupmappers.log"
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -103,7 +103,7 @@ rule count_dedup_mappers:
 rule count_unique_dedup_mappers:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique_dedup.bam", combo=scombo)
     output: u = "COUNTS/{combo}/{file}_mapped_unique_dedup.count"
-    log:    "LOGS/{combo}/{file}/count_unique_dedupmappers.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/count_unique_dedupmappers.log"
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -114,7 +114,7 @@ rule featurecount:
     input:  s = expand("MAPPED/{combo}/{{file}}_mapped_sorted.bam", combo=scombo)
     output: t = temp("COUNTS/Featurecounts_{feat}s/{combo}/{file}_tmp.counts"),
             cts = "COUNTS/Featurecounts_{feat}s/{combo}/{file}_mapped_sorted.counts.gz"
-    log:    "LOGS/{combo}/{file}/featurecount_{feat}s.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/featurecount_{feat}s.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -124,13 +124,13 @@ rule featurecount:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/"
 
 rule featurecount_unique:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique.bam", combo=scombo)
     output: t = temp("COUNTS/Featurecounts_{feat}s/{combo}/{file}_tmp_uni.counts"),
             cts = "COUNTS/Featurecounts_{feat}s/{combo}/{file}_mapped_sorted_unique.counts.gz"
-    log:    "LOGS/{combo}/{file}/featurecount_{feat}s_unique.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/featurecount_{feat}s_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -140,13 +140,13 @@ rule featurecount_unique:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/"
 
 rule featurecount_dedup:
     input:  s = expand("MAPPED/{combo}/{{file}}_mapped_sorted_dedup.bam", combo=scombo)
     output: t = temp("COUNTS/Featurecounts_{feat}s/{combo}/{file}_dedup_tmp.counts"),
             cts = "COUNTS/Featurecounts_{feat}s/{combo}/{file}_mapped_sorted_dedup.counts.gz"
-    log:    "LOGS/{combo}/{file}/featurecount_{feat}s_dedup.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/featurecount_{feat}s_dedup.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -156,13 +156,13 @@ rule featurecount_dedup:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/"
 
 rule featurecount_unique_dedup:
     input:  u = expand("MAPPED/{combo}/{{file}}_mapped_sorted_unique_dedup.bam", combo=scombo)
     output: t = temp("COUNTS/Featurecounts_{feat}s/{combo}/{file}_dedup_tmp_uni.counts"),
             cts = "COUNTS/Featurecounts_{feat}s/{combo}/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/{combo}/{file}/featurecount_{feat}s_unique_dedup.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/countreads/featurecount_{feat}s_unique_dedup.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -172,7 +172,7 @@ rule featurecount_unique_dedup:
             paired = lambda x: '-p' if paired == 'paired' else '',
             stranded = lambda x: '-s 1' if stranded == 'fr' else '-s 2' if stranded == 'rf' else '',
             sortmem = get_sortmem
-    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary"
+    shell:  "{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/"
 
 if rundedup:
     rule summarize_counts:
@@ -183,7 +183,7 @@ if rundedup:
                 d = rules.count_dedup_mappers.output,
                 x = rules.count_unique_dedup_mappers.output
         output: "COUNTS/{combo}/{file}.summary"
-        log:    "LOGS/{combo}/{file}/summarize_counts.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/summarize_counts.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -203,7 +203,7 @@ if rundedup:
                  anno_u = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped_unique.samples.gz",
                  anno_d = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped_dedup.samples.gz",
                  anno_ud = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped_unique_dedup.samples.gz"
-        log:     "LOGS/DE/{combo}/Prepare_{feat}_count_table.log"
+        log:     "LOGS/{combo}/COUNTING/countreads/Prepare_{feat}_count_table.log"
         conda:   "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -221,7 +221,7 @@ else:
                 m = rules.count_mappers.output,
                 u = rules.count_unique_mappers.output
         output: "COUNTS/{combo}/{file}.summary"
-        log:    "LOGS/{combo}/{file}/summarize_counts.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/countreads/summarize_counts.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -235,7 +235,7 @@ else:
                  tbl_u  = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped_unique.counts.gz",
                  anno  = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped.samples.gz",
                  anno_u = "COUNTS/Featurecounts_{feat}s/{combo}/COUNTS_mapped_unique.samples.gz"
-        log:     "LOGS/DE/{combo}/Prepare_{feat}_count_table.log"
+        log:     "LOGS/{combo}/COUNTING/countreads/Prepare_{feat}_count_table.log"
         conda:   "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
@@ -250,7 +250,7 @@ rule cpm_tpm_table:
     output:
         cpm = "COUNTS/Featurecounts_{feat}s/{combo}/CPM_COUNTS_mapped_unique.counts.gz" if not rundedup else "COUNTS/Featurecounts_{feat}s/{combo}/CPM_COUNTS_mapped_unique_dedup.counts.gz",
         tpm = "COUNTS/Featurecounts_{feat}s/{combo}/TPM_COUNTS_mapped_unique.counts.gz" if not rundedup else "COUNTS/Featurecounts_{feat}s/{combo}/TPM_COUNTS_mapped_unique_dedup.counts.gz"
-    log: "LOGS/DE/{combo}/CPM_TPM_{feat}_table.log"
+    log: "LOGS/{combo}/COUNTING/countreads/CPM_TPM_{feat}_table.log"
     conda: "deseq2_DE.yaml"
     container: "oras://jfallmann/monsda:deseq2_DE"
     threads: 1
diff --git a/workflows/cutadapt.nf b/workflows/cutadapt.nf
index 6ffacab6..c0f3c50d 100644
--- a/workflows/cutadapt.nf
+++ b/workflows/cutadapt.nf
@@ -15,7 +15,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)                "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/cutadapt/${file(filename).getSimpleName()}.log"
         else null
     }
 
diff --git a/workflows/cutadapt.smk b/workflows/cutadapt.smk
index 12f05a76..dad933f8 100644
--- a/workflows/cutadapt.smk
+++ b/workflows/cutadapt.smk
@@ -6,7 +6,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/8),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -29,7 +29,7 @@ else:
     rule cutadapt_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/cutadapt/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: min(int(MAXTHREAD/8),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 73b5b3b6..d55480d1 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -30,7 +30,7 @@ process featurecount_deseq{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DE/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DE/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"              
-        else if (filename.indexOf(".log") > 0)        "LOGS/DE/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/featurecounts_deseq2_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getSimpleName()}/DE/deseq2/featurecounts_deseq2_unique.log"
     }
 
     input:
@@ -79,7 +79,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DE/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DE/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DE/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DE/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DE/deseq2/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -111,7 +111,7 @@ process run_deseq2{
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DE/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/${SCOMBO}/run_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/run_deseq2.log"
     }
 
     input:
@@ -145,7 +145,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/filter_deseq2.log"
     }
 
     input:
@@ -171,7 +171,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/filter_deseq2.log"
     }
 
     input:
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 510b18ba..0982f1a2 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -28,7 +28,7 @@ rule featurecount_unique:
             tmph  = temp("DE/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc  = temp("DE/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DE/{combo}/{file}_featurecounts_deseq2_unique.log"
+    log:    "LOGS/{combo}/{file}/DE/deseq2/featurecounts_deseq2_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -44,7 +44,7 @@ rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output:  tbl  = "DE/{combo}/Tables/{scombo}_COUNTS.gz",
              anno = "DE/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:     "LOGS/DE/{combo}/{scombo}_prepare_count_table.log"
+    log:     "LOGS/{combo}/DE/deseq2/{scombo}_prepare_count_table.log"
     conda:   ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
@@ -65,7 +65,7 @@ rule run_deseq2:
             vst    = rules.themall.input.vst,
             heat   = rules.themall.input.heat,
             heats  = rules.themall.input.heats
-    log:    expand("LOGS/DE/{combo}/run_deseq2.log", combo=combo)
+    log:    expand("LOGS/{combo}/DE/deseq2/run_deseq2.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -82,7 +82,7 @@ rule filter_significant:
     output: sig = rules.themall.input.sig,
             sig_d = rules.themall.input.sig_d,
             sig_u = rules.themall.input.sig_u
-    log:    "LOGS/DE/filter_deseq2.log"
+    log:    expand("LOGS/{combo}/DE/deseq2/filter_deseq2.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
@@ -105,7 +105,7 @@ rule create_summary_snippet:
             # rules.filter_significant.output.sig_d,
             # rules.filter_significant.output.sig_u
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DE/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DE/deseq2/create_summary_snippet.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/dexseq_DEU.nf b/workflows/dexseq_DEU.nf
index 3648bdb7..7c477ac9 100644
--- a/workflows/dexseq_DEU.nf
+++ b/workflows/dexseq_DEU.nf
@@ -28,7 +28,7 @@ process prepare_deu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gtf.gz") > 0)      "${DEUREFDIR}/${file(filename).getName().replaceAll(/\Qdexseqflat\E/,"dexseq")}"
-        else if (filename.indexOf(".log") > 0)        "LOGS/DEU/${SCOMBO}/featurecount_dexseq_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/DEU/dexseq/featurecount_dexseq_annotation.log"
     }
 
     input:
@@ -69,7 +69,7 @@ process featurecount_dexseq{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DEU/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DEU/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DEU/${SCOMBO}/${file(filename).getSimpleName()}/featurecounts_dexseq_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${file(filename).getSimpleName()}/DEU/dexseq/featurecounts_dexseq_unique.log"
     }
 
     input:
@@ -118,7 +118,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DEU/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DEU/dexseq/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -151,7 +151,7 @@ process run_dexseq{
         else if (filename.indexOf("_figure") > 0)      "DEU/${SCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf(".html") > 0)      "DEU/${SCOMBO}/DEXSeqReport_${COMBO}_${DEUCOMP}/${file(filename).getName()}"
         else if (filename.indexOf("SESSION") > 0)      "DEU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/${SCOMBO}/run_dexseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/dexseq/run_dexseq.log"
     }
 
     input:
@@ -189,7 +189,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DEU/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/dexseq/filter_deseq2.log"
     }
 
     input:
@@ -215,7 +215,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/filter_dexseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/dexseq/filter_dexseq.log"
     }
 
     input:
diff --git a/workflows/dexseq_DEU.smk b/workflows/dexseq_DEU.smk
index b50e7d8f..9b3ce5ad 100644
--- a/workflows/dexseq_DEU.smk
+++ b/workflows/dexseq_DEU.smk
@@ -27,7 +27,7 @@ rule prepare_deu_annotation:
     input:  anno = ANNOTATION
     output: countgtf = expand("{countanno}", countanno=annotation_output(ANNOTATION, '_fc_dexseq.gtf')),
             deugtf   = expand("{deuanno}", deuanno=annotation_output(ANNOTATION, '_dexseq.gtf'))
-    log:    expand("LOGS/DEU/{combo}/featurecount_dexseq_annotation.log", combo=combo)
+    log:    expand("LOGS/{combo}/DEU/dexseq/featurecount_dexseq_annotation.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -43,7 +43,7 @@ rule featurecount_unique:
             tmph = temp("DEU/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc = temp("DEU/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DEU/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DEU/{combo}/{file}_featurecounts_dexseq_unique.log"
+    log:    "LOGS/{combo}/{file}/DEU/dexseq/featurecounts_dexseq_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -59,7 +59,7 @@ rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output:  tbl  = "DEU/{combo}/Tables/{scombo}_COUNTS.gz",
              anno = "DEU/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:     "LOGS/DEU/{combo}/{scombo}_prepare_count_table.log"
+    log:     "LOGS/{combo}/DEU/dexseq/{scombo}_prepare_count_table.log"
     conda:   ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
@@ -77,7 +77,7 @@ rule run_dexseq:
             siglist = rules.themall.input.siglist,
             tbl     = rules.themall.input.tbl,
             session = rules.themall.input.session
-    log:    expand("LOGS/DEU/{combo}_{scombo}_{comparison}/run_dexseq.log", combo=combo, comparison=compstr, scombo=scombo)
+    log:    expand("LOGS/{combo}_{scombo}_{comparison}/DEU/dexseq/run_dexseq.log", combo=combo, comparison=compstr, scombo=scombo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1  # Due to BPPARAM errors, else int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -94,7 +94,7 @@ rule filter_significant:
     output: sig = rules.themall.input.sig,
             sig_d = rules.themall.input.sig_d,
             sig_u = rules.themall.input.sig_u
-    log:    "LOGS/DEU/filter_dexseq.log"
+    log:    expand("LOGS/{combo}/DEU/dexseq/filter_dexseq.log", combo=combo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
@@ -112,7 +112,7 @@ rule create_summary_snippet:
             rules.filter_significant.output.sig_u,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DEU/{combo}/create_summary_snippet.log" ,combo=combo)
+    log:    expand("LOGS/{combo}/DEU/dexseq/create_summary_snippet.log" ,combo=combo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/dexseq_DTU.nf b/workflows/dexseq_DTU.nf
index f4f6d2b0..5bfb8bcc 100644
--- a/workflows/dexseq_DTU.nf
+++ b/workflows/dexseq_DTU.nf
@@ -35,7 +35,7 @@ process salmon_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/dexseq_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/dexseq/index.log"
         else if (filename == "dexseq.idx")            "$DTUIDX"
         else                                          "$DTUUIDX"
     }
@@ -71,7 +71,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_dexseq_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/DTU/dexseq/featurecount_dexseq_annotation.log"
     }
 
     output:
@@ -99,7 +99,7 @@ process run_dexseq{
         else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/DEXSeqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
         else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_dexseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DTU/dexseq/run_dexseq.log"
     }
 
     input:path counts
diff --git a/workflows/dexseq_DTU.smk b/workflows/dexseq_DTU.smk
index ff8eada9..5a429f78 100644
--- a/workflows/dexseq_DTU.smk
+++ b/workflows/dexseq_DTU.smk
@@ -31,7 +31,7 @@ rule run_DTU:
     input:  anno = expand(rules.create_annotation_table.output.anno, combo=combo, scombo=scombo)
     output: session = expand(rules.themall.input.session, combo=combo, scombo=scombo),
             res = rules.themall.input.res
-    log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
+    log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/run_DTU.log", combo=combo, scombo=scombo, comparison=compstr)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1  # Due to BPPARAM errors, else int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -50,7 +50,7 @@ rule run_DTU:
 #     output: sig   = rules.themall.input.sig,
 #             sig_d = rules.themall.input.sig_d,
 #             sig_u = rules.themall.input.sig_u
-#     log:    expand("LOGS/DTU/{combo}_{scombo}_{comparison}/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
+#     log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
 #     conda:  ""+DTUENV+".yaml"
 #     threads: 1
 #     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
@@ -64,7 +64,7 @@ rule create_summary_snippet:
             # rules.filter_significant.output.sig_d,
             # rules.filter_significant.output.sig_u,
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/dexseq/create_summary_snippet.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/diego_DAS.nf b/workflows/diego_DAS.nf
index b0a40373..cd97a008 100644
--- a/workflows/diego_DAS.nf
+++ b/workflows/diego_DAS.nf
@@ -32,7 +32,7 @@ process featurecount_diego{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DAS/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DAS/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"               
-        else if (filename.indexOf(".log") > 0)        "LOGS/DAS/${SCOMBO}/${file(filename).getSimpleName()}/featurecounts_diego_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${file(filename).getSimpleName()}/DAS/diego/featurecounts_diego_unique.log"
     }
 
     input:
@@ -81,7 +81,7 @@ process create_samplemaps{
     saveAs: {filename ->
         if (filename == "samplemap.txt")      "DAS/${SCOMBO}/Tables/${COMBO}_samplemap.txt"
         else if (filename == "groupings.txt")      "DAS/${SCOMBO}/Tables/${COMBO}_grouping.txt"
-        else if (filename == "log")      "LOGS/DAS/${SCOMBO}/${COMBO}_create_samplemaps.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DAS/diego/${COMBO}_create_samplemaps.log"
     }
 
     output: 
@@ -107,7 +107,7 @@ process prepare_junction_usage_matrix{
     saveAs: {filename ->
         if (filename == "junction_table.txt.gz")      "DAS/${SCOMBO}/Tables/${COMBO}_junction_table_dexdas.txt.gz"
         else if (filename == "ANNOTATION.gz")      "DAS/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
-        else if (filename == "log")      "LOGS/DAS/${SCOMBO}/${COMBO}_junction_usage_matrix.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DAS/diego/${COMBO}_junction_usage_matrix.log"
     }
 
     input:
@@ -136,7 +136,7 @@ process create_contrast_files{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("contrast.txt") > 0 )      "DAS/${SCOMBO}/Tables/${COMBO}_contrast.txt"
-        else if (filename == "log")      "LOGS/DAS/${SCOMBO}/${COMBO}_create_contrast_files.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DAS/diego/${COMBO}_create_contrast_files.log"
     }
 
     input:
@@ -163,7 +163,7 @@ process run_diego{
     saveAs: {filename ->
         if (filename.indexOf("csv") > 0)      "DAS/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("dendrogram") > 0)      "DAS/${SCOMBO}/Figures/${file(filename).getName()}"                
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/${SCOMBO}_${COMBO}_${COMPSTR}/run_diego.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}_${COMBO}_${COMPSTR}/DAS/diego/run_diego.log"
     }
 
     input:
@@ -194,7 +194,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DAS/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DAS/diego/filter_deseq2.log"
     }
 
     input:
@@ -246,7 +246,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/filter_diego.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DAS/diego/filter_diego.log"
     }
 
     input:
diff --git a/workflows/diego_DAS.smk b/workflows/diego_DAS.smk
index 8cb45d0c..e8497712 100644
--- a/workflows/diego_DAS.smk
+++ b/workflows/diego_DAS.smk
@@ -20,7 +20,7 @@ rule featurecount_unique:
             tmph = temp("DAS/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc = temp("DAS/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DAS/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DAS/{combo}/{file}_featurecounts_diego_unique.log"
+    log:    "LOGS/{combo}/{file}/DAS/diego/featurecounts_diego_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -37,7 +37,7 @@ rule create_samplemaps:
     input:  cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output: smap = "DAS/{combo}/Tables/{scombo}_samplemap.txt",
             cmap = "DAS/{combo}/Tables/{scombo}_groupings.txt"
-    log:    "LOGS/DAS/{combo}/{scombo}_create_samplemaps.log"
+    log:    "LOGS/{combo}/DAS/diego/{scombo}_create_samplemaps.log"
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -52,7 +52,7 @@ rule prepare_junction_usage_matrix:
             cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output: tbl = "DAS/{combo}/Tables/{scombo}_junction_table_dexdas.txt.gz",
             anno = "DAS/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:    "LOGS/DAS/{combo}/prepare_{scombo}_junction_usage_matrix.log"
+    log:    "LOGS/{combo}/DAS/diego/prepare_{scombo}_junction_usage_matrix.log"
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -64,7 +64,7 @@ rule prepare_junction_usage_matrix:
 rule create_contrast_files:
     input:  anno = expand(rules.prepare_junction_usage_matrix.output.anno, combo=combo, scombo=scombo)
     output: contrast = expand("DAS/{combo}/Tables/{scombo}_{comparison}_contrast.txt", combo=combo, scombo=scombo, comparison=compstr)
-    log:    expand("LOGS/DAS/{combo}/create_contrast_files.log", combo=combo)
+    log:    expand("LOGS/{combo}/DAS/diego/create_contrast_files.log", combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -80,7 +80,7 @@ rule run_diego:
             contrast = expand(rules.create_contrast_files.output.contrast, combo=combo, scombo=scombo)
     output: dendrogram = rules.themall.input.dendrogram,
             csv = rules.themall.input.csv
-    log:    expand("LOGS/DAS/{combo}_{scombo}_{comparison}/run_diego.log", combo=combo, comparison=compstr, scombo=scombo)
+    log:    expand("LOGS/{combo}_{scombo}_{comparison}/DAS/diego/run_diego.log", combo=combo, comparison=compstr, scombo=scombo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: MAXTHREAD
@@ -94,7 +94,7 @@ rule run_diego:
 rule filter_significant:
     input:  csv = rules.run_diego.output.csv
     output: sig = rules.themall.input.sig
-    log:    "LOGS/DAS/filter_diegoDAS.log"
+    log:    expand("LOGS/{combo}/DAS/diego/filter_diegoDAS.log", combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -106,7 +106,7 @@ rule filter_significant:
 rule convertPDF:
     input: rules.run_diego.output.dendrogram
     output: dendrogram = expand("DAS/{combo}/Figures/DAS_DIEGO_{scombo}_{comparison}_figure_dendrogram.png", combo=combo, scombo=scombo, comparison=compstr)
-    log:    expand("LOGS/DAS/{combo}_{scombo}_{comparison}/convertPDF.log", combo=combo, comparison=compstr, scombo=scombo)
+    log:    expand("LOGS/{combo}_{scombo}_{comparison}/DAS/diego/convertPDF.log", combo=combo, comparison=compstr, scombo=scombo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: MAXTHREAD
@@ -120,7 +120,7 @@ rule create_summary_snippet:
             #rules.run_diego.output.sig_d,
             #rules.run_diego.output.sig_u
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DAS/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DAS/diego/create_summary_snippet.log", combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/dorado.nf b/workflows/dorado.nf
index e2565f2e..44a1451e 100644
--- a/workflows/dorado.nf
+++ b/workflows/dorado.nf
@@ -16,7 +16,7 @@ process dorado{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".fastq.gz") > 0)      "FASTQ/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") > 0)        "LOGS/BASECALL/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${CONDITION}/BASECALL/dorado/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/dorado.smk b/workflows/dorado.smk
index b16d59ec..217c2094 100644
--- a/workflows/dorado.smk
+++ b/workflows/dorado.smk
@@ -10,7 +10,7 @@ rule call_base:
     input:  p5 = "RAW/{rawfile}.pod5"
     output: fq = "FASTQ/{rawfile}.fastq.gz",
             bam = temp("FASTQ/{rawfile}.bam")
-    log:    "LOGS/BASECALL/{rawfile}_dorado.log"
+    log:    "LOGS/{rawfile}/BASECALL/dorado/dorado.log"
     conda:  ""+CALLERENV+".yaml"
     container: "oras://jfallmann/monsda:"+CALLERENV+""
     threads: MAXTHREAD
diff --git a/workflows/drimseq_DTU.nf b/workflows/drimseq_DTU.nf
index f5b86d86..0beb3a86 100644
--- a/workflows/drimseq_DTU.nf
+++ b/workflows/drimseq_DTU.nf
@@ -35,7 +35,7 @@ process salmon_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/drimseq_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/drimseq/index.log"
         else if (filename == "drimseq.idx")           "$DTUIDX"
         else                                          "$DTUUIDX"
     }
@@ -71,7 +71,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_drimseq_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/DTU/drimseq/featurecount_drimseq_annotation.log"
     }
 
     output:
@@ -99,7 +99,7 @@ process run_drimseq{
         else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf(".html") > 0)      "DTU/${SCOMBO}/drimseqReport_${COMBO}_${DTUCOMP}/${file(filename).getName()}"
         else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_drimseq.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DTU/drimseq/run_drimseq.log"
     }
 
     input:
diff --git a/workflows/drimseq_DTU.smk b/workflows/drimseq_DTU.smk
index dd48d51a..f9b8cfd1 100644
--- a/workflows/drimseq_DTU.smk
+++ b/workflows/drimseq_DTU.smk
@@ -48,7 +48,7 @@ rule run_DTU:
             fig_P   = rules.themall.input.fig_P,
             fig_PV  = rules.themall.input.fig_PV,
             fig_files = rules.themall.input.fig_files
-    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/drimseq/run_DTU.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -69,7 +69,7 @@ rule filter_significant_drimseq:
             sig_t   = rules.themall.input.sig_t,
             sig_dt  = rules.themall.input.sig_dt,
             sig_ut  = rules.themall.input.sig_ut
-    log:    "LOGS/DTU/filter_drimseqDTU.log"
+    log:    expand("LOGS/{combo}/DTU/drimseq/filter_drimseqDTU.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
@@ -93,7 +93,7 @@ rule create_summary_snippet:
             rules.themall.input.sig_ut,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/drimseq/create_summary_snippet.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/dtu_base.nf b/workflows/dtu_base.nf
index d37b1e65..56c14d19 100644
--- a/workflows/dtu_base.nf
+++ b/workflows/dtu_base.nf
@@ -9,7 +9,7 @@ process salmon_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/salmon/${CONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/${CONDITION}/DTU/salmon/${file(filename).getName()}"
         else                                    "DTU/${SCOMBO}/salmon/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
     }
 
@@ -72,7 +72,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/create_summary_snippet.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DTU/salmon/create_summary_snippet.log"
     }
 
     input:
@@ -98,7 +98,7 @@ process terminus_collapse{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/terminus/${CONDITION}/DTU/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${SCOMBO}/${CONDITION}/DTU/terminus/${file(filename).getName()}"
         else                                    "DTU/${SCOMBO}/terminus/${file(filename).getName()}"
     }
 
diff --git a/workflows/dtu_base.smk b/workflows/dtu_base.smk
index e759eceb..efea123d 100644
--- a/workflows/dtu_base.smk
+++ b/workflows/dtu_base.smk
@@ -2,7 +2,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/DTU/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -14,8 +14,8 @@ rule salmon_index:
 
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -25,7 +25,7 @@ if paired == 'paired':
 
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not usededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -39,7 +39,7 @@ if paired == 'paired':
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -56,7 +56,7 @@ else:
                 uix = rules.salmon_index.output.uidx
         output: cnts = report("DTU/{combo}/salmon/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("DTU/{combo}/salmon/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -71,7 +71,7 @@ if runterminus:
     rule terminus_group:
         input:  ctsdir = rules.mapping.output.ctsdir
         output: grp = "DTU/{combo}/terminus/{file}/groups.txt"
-        log:    "LOGS/{combo}/{file}/terminus_group.log"
+        log:    "LOGS/{combo}/{file}/DTU/salmon/terminus_group.log"
         conda:  ""+TERMINUSENV+".yaml"
         container: "oras://jfallmann/monsda:"+TERMINUSENV+""
         threads: MAXTHREAD
@@ -83,7 +83,7 @@ if runterminus:
         input:  grps = expand("DTU/{combo}/terminus/{file}/groups.txt", combo=combo, file=samplecond(SAMPLES, config)),
                 dirs = expand(rules.mapping.output.ctsdir, combo=combo, file=samplecond(SAMPLES, config))
         output: cnts = expand("DTU/{combo}/terminus/{file}/quant.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
-        log:    expand("LOGS/DTU/{combo}/terminus_collapse.log", combo=combo)
+        log:    expand("LOGS/{combo}/DTU/salmon/terminus_collapse.log", combo=combo)
         conda:  ""+TERMINUSENV+".yaml"
         container: "oras://jfallmann/monsda:"+TERMINUSENV+""
         threads: MAXTHREAD
@@ -97,7 +97,7 @@ else:
 rule create_annotation_table:
     input:  dir  = ctsource,
     output: anno = expand("DTU/{combo}/Tables/{scombo}_ANNOTATION.gz", combo=combo, scombo=scombo)
-    log:    expand("LOGS/DTU/{combo}/create_DTU_table.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/salmon/create_DTU_table.log", combo=combo)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: 1
diff --git a/workflows/edger_DAS.nf b/workflows/edger_DAS.nf
index cedb3a93..ffafedfc 100644
--- a/workflows/edger_DAS.nf
+++ b/workflows/edger_DAS.nf
@@ -30,7 +30,7 @@ process featurecount_edger{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DAS/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DAS/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"               
-        else if (filename.indexOf(".log") > 0)        "LOGS/DAS/${SCOMBO}/${file(filename).getSimpleName()}/featurecounts_edger_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${file(filename).getSimpleName()}/DAS/edger/featurecounts_edger_unique.log"
     }
 
     input:
@@ -79,7 +79,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DAS/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DAS/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DAS/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DAS/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DAS/edger/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -111,7 +111,7 @@ process run_edger{
         if (filename.indexOf("_table") > 0)      "DAS/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DAS/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DAS/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/${SCOMBO}/run_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DAS/edger/run_edger.log"
     }
 
     input:
@@ -146,7 +146,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DAS/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DAS/edger/filter_deseq2.log"
     }
 
     input:
@@ -172,7 +172,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DAS/filter_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DAS/edger/filter_edger.log"
     }
 
     input:
diff --git a/workflows/edger_DAS.smk b/workflows/edger_DAS.smk
index da9e715e..dbddabfe 100644
--- a/workflows/edger_DAS.smk
+++ b/workflows/edger_DAS.smk
@@ -25,7 +25,7 @@ rule featurecount_unique:
             tmph = temp("DAS/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc = temp("DAS/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DAS/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DAS/{combo}/{file}_featurecounts_edger_unique.log"
+    log:    "LOGS/{combo}/{file}/DAS/edger/featurecounts_edger_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -42,7 +42,7 @@ rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output:  tbl  = "DAS/{combo}/Tables/{scombo}_COUNTS.gz",
              anno = "DAS/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:     "LOGS/DAS/{combo}/{scombo}_prepare_count_table.log"
+    log:     "LOGS/{combo}/DAS/edger/{scombo}_prepare_count_table.log"
     conda:   ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -61,7 +61,7 @@ rule run_edger:
             list    = rules.themall.input.list,
             resS    = rules.themall.input.resS,
             resE    = rules.themall.input.resE
-    log:    expand("LOGS/DE/{combo}/run_edger.log", combo=combo)
+    log:    expand("LOGS/{combo}/DAS/edger/run_edger.log", combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -78,7 +78,7 @@ rule filter_significant_edger:
     output: sig= rules.themall.input.sig,
             sig_d= rules.themall.input.sig_d,
             sig_u= rules.themall.input.sig_u,
-    log:    "LOGS/DAS/filter_edgerDAS.log"
+    log:    expand("LOGS/{combo}/DAS/edger/filter_edgerDAS.log", combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
@@ -99,7 +99,7 @@ rule create_summary_snippet:
             rules.themall.input.sig_u,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DAS/{combo}/create_summary_snippet.log",combo=combo)
+    log:    expand("LOGS/{combo}/DAS/edger/create_summary_snippet.log",combo=combo)
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index c53faa57..080ffbf6 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -30,7 +30,7 @@ process featurecount_edger{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DE/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DE/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"               
-        else if (filename.indexOf(".log") > 0)        "LOGS/DE/${SCOMBO}/${file(filename).getSimpleName()}/featurecounts_edger_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${file(filename).getSimpleName()}/DE/edger/featurecounts_edger_unique.log"
     }
 
     input:
@@ -79,7 +79,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DE/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DE/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DE/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DE/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DE/edger/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -111,7 +111,7 @@ process run_edger{
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DE/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/${SCOMBO}/run_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/run_edger.log"
     }
 
     input:
@@ -145,7 +145,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/filter_deseq2.log"
     }
 
     input:
@@ -171,7 +171,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DE/filter_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/filter_edger.log"
     }
 
     input:
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index dea7f25b..d7d6578f 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -27,7 +27,7 @@ rule featurecount_unique:
             tmph  = temp("DE/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc  = temp("DE/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DE/{combo}/{file}_featurecounts_edger_unique.log"
+    log:    "LOGS/{combo}/{file}/DE/edger/featurecounts_edger_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -43,7 +43,7 @@ rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output:  tbl  = "DE/{combo}/Tables/{scombo}_COUNTS.gz",
              anno = "DE/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:     "LOGS/DE/{combo}/{scombo}_prepare_count_table.log"
+    log:     "LOGS/{combo}/DE/edger/{scombo}_prepare_count_table.log"
     conda:   ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
@@ -63,7 +63,7 @@ rule run_edger:
             allN    = rules.themall.input.allN,
             res     = rules.themall.input.res,
             sort    = rules.themall.input.sort
-    log:    expand("LOGS/DE/{combo}/run_edger.log", combo=combo)
+    log:    expand("LOGS/{combo}/DE/edger/run_edger.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -80,7 +80,7 @@ rule filter_significant:
     output: sig = rules.themall.input.sig,
             sig_d = rules.themall.input.sig_d,
             sig_u = rules.themall.input.sig_u
-    log:    "LOGS/DE/filter_edgerDE.log"
+    log:    expand("LOGS/{combo}/DE/edger/filter_edgerDE.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
@@ -103,7 +103,7 @@ rule create_summary_snippet:
             rules.filter_significant.output.sig_d,
             rules.filter_significant.output.sig_u
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DE/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DE/edger/create_summary_snippet.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/edger_DEU.nf b/workflows/edger_DEU.nf
index a0a27db1..4bcc3123 100644
--- a/workflows/edger_DEU.nf
+++ b/workflows/edger_DEU.nf
@@ -30,7 +30,7 @@ process featurecount_edger{
     saveAs: {filename ->
         if (filename.indexOf(".counts.gz") > 0)      "DEU/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".counts.summary") > 0)      "DEU/${SCOMBO}/Featurecounts/${CONDITION}/${file(filename).getName()}"               
-        else if (filename.indexOf(".log") > 0)        "LOGS/DEU/${SCOMBO}/${file(filename).getSimpleName()}/featurecounts_edger_unique.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${file(filename).getSimpleName()}/DEU/edger/featurecounts_edger_unique.log"
     }
 
     input:
@@ -79,7 +79,7 @@ process prepare_count_table{
         if (filename == "COUNTS.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_COUNTS.gz"
         else if (filename == "ANNOTATION.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_ANNOTATION.gz"
         else if (filename == "SampleDict.gz")      "DEU/${SCOMBO}/Tables/${COMBO}_SampleDict.gz"
-        else if (filename == "log")      "LOGS/DEU/${SCOMBO}/${COMBO}_prepare_count_table.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/DEU/edger/${COMBO}_prepare_count_table.log"
     }
 
     input:
@@ -111,7 +111,7 @@ process run_edger{
         if (filename.indexOf("_table") > 0)      "DEU/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DEU/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DEU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/${SCOMBO}/run_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/edger/run_edger.log"
     }
 
     input:
@@ -145,7 +145,7 @@ process filter_significant{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_table") > 0)      "DEU/${SCOMBO}/Tables/${file(filename).getName()}"                                
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/filter_deseq2.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/edger/filter_deseq2.log"
     }
 
     input:
@@ -171,7 +171,7 @@ process create_summary_snippet{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".Rmd") > 0)         "REPORTS/SUMMARY/RmdSnippets/${SCOMBO}.Rmd"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/DEU/filter_edger.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DEU/edger/filter_edger.log"
     }
 
     input:
diff --git a/workflows/edger_DEU.smk b/workflows/edger_DEU.smk
index 0f220503..df4459ae 100644
--- a/workflows/edger_DEU.smk
+++ b/workflows/edger_DEU.smk
@@ -25,7 +25,7 @@ rule featurecount_unique:
             tmph = temp("DEU/{combo}/Featurecounts/{file}_tmp.head.gz"),
             tmpc = temp("DEU/{combo}/Featurecounts/{file}_tmp.count.gz"),
             cts   = "DEU/{combo}/Featurecounts/{file}_mapped_sorted_unique.counts.gz" if not usededup else "DE/{combo}/Featurecounts/{file}_mapped_sorted_unique_dedup.counts.gz"
-    log:    "LOGS/DEU/{combo}/{file}_featurecounts_edger_unique.log"
+    log:    "LOGS/{combo}/{file}/DEU/edger/featurecounts_edger_unique.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -42,7 +42,7 @@ rule prepare_count_table:
     input:   cnd  = expand(rules.featurecount_unique.output.cts, combo=combo, file=samplecond(SAMPLES, config))
     output:  tbl  = "DEU/{combo}/Tables/{scombo}_COUNTS.gz",
              anno = "DEU/{combo}/Tables/{scombo}_ANNOTATION.gz"
-    log:     "LOGS/DEU/{combo}/{scombo}_prepare_count_table.log"
+    log:     "LOGS/{combo}/DEU/edger/{scombo}_prepare_count_table.log"
     conda:   ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
@@ -60,7 +60,7 @@ rule run_edger:
             rules.themall.input.MDplot,
             rules.themall.input.allN,
             rules.themall.input.res,
-    log:    expand("LOGS/DE/{combo}/run_edger.log", combo=combo)
+    log:    expand("LOGS/{combo}/DEU/edger/run_edger.log", combo=combo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -77,7 +77,7 @@ rule filter_significant:
     output: sig = rules.themall.input.sig,
             sig_d = rules.themall.input.sig_d,
             sig_u = rules.themall.input.sig_u
-    log:    "LOGS/DEU/filter_edgerDEU.log"
+    log:    expand("LOGS/{combo}/DEU/edger/filter_edgerDEU.log", combo=combo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
@@ -98,7 +98,7 @@ rule create_summary_snippet:
             rules.filter_significant.output.sig_u,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DEU/{combo}/create_summary_snippet.log",combo=combo)
+    log:    expand("LOGS/{combo}/DEU/edger/create_summary_snippet.log",combo=combo)
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/fastp.nf b/workflows/fastp.nf
index 52911edc..bd7eab22 100644
--- a/workflows/fastp.nf
+++ b/workflows/fastp.nf
@@ -15,7 +15,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/fastp/${file(filename).getSimpleName()}.log"
         else null
     }
 
diff --git a/workflows/fastp.smk b/workflows/fastp.smk
index 8beb2b30..11bcb549 100644
--- a/workflows/fastp.smk
+++ b/workflows/fastp.smk
@@ -6,7 +6,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/fastp/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: MAXTHREAD
@@ -28,7 +28,7 @@ else:
     rule fastp_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/fastp/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: MAXTHREAD
diff --git a/workflows/fastqc.smk b/workflows/fastqc.smk
index 7694bbaa..8ef7e19d 100644
--- a/workflows/fastqc.smk
+++ b/workflows/fastqc.smk
@@ -5,7 +5,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -27,7 +27,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -50,7 +50,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -61,7 +61,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -72,7 +72,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/fastqc/fastqc_mapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -83,7 +83,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquemapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -94,7 +94,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedupmapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -105,7 +105,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_uniquededup.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
diff --git a/workflows/fastqc_dedup.smk b/workflows/fastqc_dedup.smk
index 923115c0..df9010e3 100644
--- a/workflows/fastqc_dedup.smk
+++ b/workflows/fastqc_dedup.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -50,7 +50,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -60,7 +60,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -73,7 +73,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/fastqc_dedup_trim.smk b/workflows/fastqc_dedup_trim.smk
index 08d5f183..3cb50285 100644
--- a/workflows/fastqc_dedup_trim.smk
+++ b/workflows/fastqc_dedup_trim.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -36,7 +36,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -50,7 +50,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -61,7 +61,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -71,7 +71,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -81,7 +81,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -95,7 +95,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/fastqc_raw.smk b/workflows/fastqc_raw.smk
index 05efccc4..450b5bad 100644
--- a/workflows/fastqc_raw.smk
+++ b/workflows/fastqc_raw.smk
@@ -5,7 +5,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -17,7 +17,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -28,7 +28,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -40,7 +40,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/fastqc_trim.smk b/workflows/fastqc_trim.smk
index 5446e889..9e4316d6 100644
--- a/workflows/fastqc_trim.smk
+++ b/workflows/fastqc_trim.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -50,7 +50,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/QC/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/fastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -60,7 +60,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/QC/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/fastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -73,7 +73,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/fgumi.nf b/workflows/fgumi.nf
index 9e9547b9..aaade354 100644
--- a/workflows/fgumi.nf
+++ b/workflows/fgumi.nf
@@ -13,7 +13,7 @@ process extract_fq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_dedup.fastq.gz") > 0)      "DEDUP_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.fastq.gz"
-        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/dedup_extract.log"
+        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/fgumi/extract.log"
         else null
     }
 
diff --git a/workflows/fgumi.smk b/workflows/fgumi.smk
index edeacf1e..514fc0e9 100644
--- a/workflows/fgumi.smk
+++ b/workflows/fgumi.smk
@@ -11,7 +11,7 @@ if paired == 'paired':
                 o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
                 ubam = "TMP/FGEX/{combo}/{file}_extracted.bam",
                 td = temp(directory("TMP/FGEX/{combo}/{file}"))
-        log:   "LOGS/{combo}/{file}_dedup_extract.log"
+        log:   "LOGS/{combo}/{file}/DEDUP/fgumi/dedup_extract.log"
         conda: ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
@@ -25,7 +25,7 @@ else:
         output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
                 ubam = "TMP/FGEX/{combo}/{file}_extracted.bam",
                 td = temp(directory("TMP/FGEX/{combo}/{file}"))
-        log:   "LOGS/{combo}/{file}_dedup_extract.log"
+        log:   "LOGS/{combo}/{file}/DEDUP/fgumi/dedup_extract.log"
         conda: ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
@@ -41,7 +41,7 @@ if paired == 'paired':
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/fgumi/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 4
@@ -67,7 +67,7 @@ else:
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/fgumi/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 4
diff --git a/workflows/fgumi_dedup.nf b/workflows/fgumi_dedup.nf
index 608b288b..24427f87 100644
--- a/workflows/fgumi_dedup.nf
+++ b/workflows/fgumi_dedup.nf
@@ -14,7 +14,7 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/fgumi/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/fgumi_dedup.smk b/workflows/fgumi_dedup.smk
index 49d54982..4b77ce1c 100644
--- a/workflows/fgumi_dedup.smk
+++ b/workflows/fgumi_dedup.smk
@@ -5,7 +5,7 @@ rule dedupbam:
     output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/fgumi/dedupbam_{type}.log"
     conda:  ""+DEDUPENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEDUPENV+""
     threads: 1
diff --git a/workflows/guppy.nf b/workflows/guppy.nf
index bf287817..936673c4 100644
--- a/workflows/guppy.nf
+++ b/workflows/guppy.nf
@@ -18,7 +18,7 @@ process guppy{
         if (filename.indexOf(".fastq.gz") > 0)      "FASTQ/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_summary.txt") > 0)      "FASTQ/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_telemetry.js") > 0)      "FASTQ/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") > 0)        "LOGS/BASECALL/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${CONDITION}/BASECALL/guppy/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/guppy.smk b/workflows/guppy.smk
index cc25317c..3079a6eb 100644
--- a/workflows/guppy.smk
+++ b/workflows/guppy.smk
@@ -11,7 +11,7 @@ rule call_base:
     output: fq = "FASTQ/{rawfile}.fastq.gz",
             summary = "FASTQ/{rawfile}_summary.txt",
             telemetry = "FASTQ/{rawfile}_telemetry.js"
-    log:    "LOGS/BASECALL/{rawfile}_guppy.log"
+    log:    "LOGS/{rawfile}/BASECALL/guppy/guppy.log"
     conda:  ""+CALLERENV+".yaml"
     container: "oras://jfallmann/monsda:"+CALLERENV+""
     threads: MAXTHREAD
diff --git a/workflows/hisat2.nf b/workflows/hisat2.nf
index cf3d3f89..63a98f41 100644
--- a/workflows/hisat2.nf
+++ b/workflows/hisat2.nf
@@ -38,7 +38,7 @@ process hisat2_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "hisat2.idx")            "$MAPIDX"
-        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/MAPPING/hisat2_index.log"
+        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/MAPPING/hisat2/index.log"
         else                                     "$MAPUIDX"
     }
 
@@ -72,7 +72,7 @@ process hisat2_mapping{
     saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)     "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
         else if (filename.indexOf(".summary") >0)            "MAPPED/${COMBO}/${CONDITION}/"+"${filename.replaceAll(/trimmed./,"")}"
-        else if (filename.indexOf(".log") >0)               "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)               "LOGS/${COMBO}/${CONDITION}/MAPPING/hisat2/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/hisat2.smk b/workflows/hisat2.smk
index dd6ce8b1..6719e04f 100644
--- a/workflows/hisat2.smk
+++ b/workflows/hisat2.smk
@@ -11,7 +11,7 @@ rule generate_index:
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref = PREFIX),
             tmp = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -34,7 +34,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 summary = "MAPPED/{combo}/{file}.summary"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/hisat2/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -56,7 +56,7 @@ else:
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                 summary = "MAPPED/{combo}/{file}.summary"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/hisat2/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/kallisto.nf b/workflows/kallisto.nf
index 1e032b57..d0c467a8 100644
--- a/workflows/kallisto.nf
+++ b/workflows/kallisto.nf
@@ -64,7 +64,7 @@ process kallisto_idx{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename == "kallisto.idx")            "$COUNTIDX"
-        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/kallisto_index.log"
+        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/kallisto/index.log"
         else                                        "$COUNTUIDX"
     }
 
@@ -96,7 +96,7 @@ process kallisto_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/kallisto/${file(filename).getName()}"
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/kallisto.smk b/workflows/kallisto.smk
index 57979545..440d19c7 100644
--- a/workflows/kallisto.smk
+++ b/workflows/kallisto.smk
@@ -12,7 +12,7 @@ rule kallisto_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=COUNTENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -30,7 +30,7 @@ if paired == 'paired':
                 uidx = rules.kallisto_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/kallistoquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/kallisto/kallistoquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -46,7 +46,7 @@ else:
                 uidx = rules.kallisto_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/kallistoquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/kallisto/kallistoquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
diff --git a/workflows/kallisto_trim.smk b/workflows/kallisto_trim.smk
index 466eeb90..79d94a93 100644
--- a/workflows/kallisto_trim.smk
+++ b/workflows/kallisto_trim.smk
@@ -10,8 +10,8 @@ rule themall:
 
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -21,7 +21,7 @@ if paired == 'paired':
 
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -31,7 +31,7 @@ rule kallisto_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=COUNTENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -49,7 +49,7 @@ if paired == 'paired':
                 uidx = rules.kallisto_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/kallistoquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/kallisto/kallistoquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -65,7 +65,7 @@ else:
                 uidx = rules.kallisto_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/kallistoquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/kallisto/kallistoquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
diff --git a/workflows/macs2.nf b/workflows/macs2.nf
index e552c2dc..ca4f15f9 100644
--- a/workflows/macs2.nf
+++ b/workflows/macs2.nf
@@ -22,7 +22,7 @@ process FindPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs2/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -67,7 +67,7 @@ process PeakToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs2/${file(filename).getName()}_peaktobedgraph.log"
     }
 
     input:
@@ -104,7 +104,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs2/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -138,7 +138,7 @@ process PeakToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/macs2/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -173,7 +173,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/PEAKS/${file(filename).getName()}"
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/macs2/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/macs2.smk b/workflows/macs2.smk
index 60f960ff..76866596 100644
--- a/workflows/macs2.smk
+++ b/workflows/macs2.smk
@@ -46,7 +46,7 @@ include: "manipulate_genome.smk"
 rule FindPeaks:
     input:  bam = expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
     output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_findpeaks_macs_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs2/findpeaks_macs_{type}.log"
     conda:  ""+PEAKENV+".yaml"
     container: "oras://jfallmann/monsda:"+PEAKENV+""
     threads: 1
@@ -65,7 +65,7 @@ rule AddSequenceToPeak:
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_seq2peaks_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs2/seq2peaks_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -77,7 +77,7 @@ if ANNOPEAK is not None:
     rule AnnotatePeak:
         input:  "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz"
         output: "PEAKS/{combo}/{file}_peak_anno_{type}.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/{file}_annotatepeaks_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs2/annotatepeaks_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -93,7 +93,7 @@ if ANNOPEAK is not None:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 trw = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs2/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -109,7 +109,7 @@ else:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs2/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -123,7 +123,7 @@ rule NormalizeBedg:
             re = rules.PeakToBedg.output.re
     output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.norm.bedg.gz",
             re = "PEAKS/{combo}/{file}_peak_{type}.re.norm.bedg.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_ucscpeaknormalizebedgraph_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs2/ucscpeaknormalizebedgraph_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -140,7 +140,7 @@ rule PeakToTRACKS:
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
             tre = temp("TRACKS/PEAKS/{combo}/{file}_{type}re_tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_peak2ucsc_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs2/peak2ucsc_{type}.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -151,7 +151,7 @@ rule GenerateTrack:
             re = rules.PeakToTRACKS.output.re
     output: "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw.trackdone"
-    log:    "LOGS/PEAKS/{combo}/{file}_peaktrack_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs2/peaktrack_{type}.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/macs3.nf b/workflows/macs3.nf
index f406b2a1..a29a612b 100644
--- a/workflows/macs3.nf
+++ b/workflows/macs3.nf
@@ -22,7 +22,7 @@ process FindPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs3/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -67,7 +67,7 @@ process PeakToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs3/${file(filename).getName()}_peaktobedgraph.log"
     }
 
     input:
@@ -104,7 +104,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/macs3/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -138,7 +138,7 @@ process PeakToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/macs3/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -173,7 +173,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/PEAKS/${file(filename).getName()}"
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/macs3/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/macs3.smk b/workflows/macs3.smk
index 60f960ff..74167e91 100644
--- a/workflows/macs3.smk
+++ b/workflows/macs3.smk
@@ -46,7 +46,7 @@ include: "manipulate_genome.smk"
 rule FindPeaks:
     input:  bam = expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
     output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_findpeaks_macs_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs3/findpeaks_macs_{type}.log"
     conda:  ""+PEAKENV+".yaml"
     container: "oras://jfallmann/monsda:"+PEAKENV+""
     threads: 1
@@ -65,7 +65,7 @@ rule AddSequenceToPeak:
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_seq2peaks_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs3/seq2peaks_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -77,7 +77,7 @@ if ANNOPEAK is not None:
     rule AnnotatePeak:
         input:  "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz"
         output: "PEAKS/{combo}/{file}_peak_anno_{type}.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/{file}_annotatepeaks_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs3/annotatepeaks_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -93,7 +93,7 @@ if ANNOPEAK is not None:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 trw = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs3/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -109,7 +109,7 @@ else:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/macs3/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -123,7 +123,7 @@ rule NormalizeBedg:
             re = rules.PeakToBedg.output.re
     output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.norm.bedg.gz",
             re = "PEAKS/{combo}/{file}_peak_{type}.re.norm.bedg.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_ucscpeaknormalizebedgraph_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs3/ucscpeaknormalizebedgraph_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -140,7 +140,7 @@ rule PeakToTRACKS:
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
             tre = temp("TRACKS/PEAKS/{combo}/{file}_{type}re_tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_peak2ucsc_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs3/peak2ucsc_{type}.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -151,7 +151,7 @@ rule GenerateTrack:
             re = rules.PeakToTRACKS.output.re
     output: "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw.trackdone"
-    log:    "LOGS/PEAKS/{combo}/{file}_peaktrack_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/macs3/peaktrack_{type}.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/manipulate_genome.nf b/workflows/manipulate_genome.nf
index 7633eb72..f5b8741c 100644
--- a/workflows/manipulate_genome.nf
+++ b/workflows/manipulate_genome.nf
@@ -10,7 +10,7 @@ process UnzipGenome{
         if (filename.indexOf(".fa.fai") > 0)      "${REFDIR}/${file(filename).getName()}"
         else if (filename.indexOf(".fa") > 0)      "${REFDIR}/${file(filename).getName()}"
         else if (filename.indexOf(".chrom.sizes") > 0)      "${REFDIR}/${file(filename).getName()}"
-        else if (filename == "log")      "LOGS/${SCOMBO}/${COMBO}_indexfa.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/MAPPING/samtools/${COMBO}_indexfa.log"
     }
 
     input:
@@ -45,7 +45,7 @@ process UnzipGenome_no_us{
         if (filename.indexOf("_us.fa.fai") > 0)      "${REFDIR}/${file(filename).getName()}"
         else if (filename.indexOf("_us.fa") > 0)      "${REFDIR}/${file(filename).getName()}"
         else if (filename.indexOf("_us.chrom.sizes") > 0)      "${REFDIR}/${file(filename).getName()}"
-        else if (filename == "log")      "LOGS/${SCOMBO}/${COMBO}_indexfa_us.log"
+        else if (filename == "log")      "LOGS/${SCOMBO}/MAPPING/samtools/${COMBO}_indexfa_us.log"
     }
 
     input:
diff --git a/workflows/manipulate_genome.smk b/workflows/manipulate_genome.smk
index e754e911..f32166c9 100644
--- a/workflows/manipulate_genome.smk
+++ b/workflows/manipulate_genome.smk
@@ -3,7 +3,7 @@ rule UnzipGenome:
     output: fa = expand("{ref}.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fai = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fas = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
-    log:    expand("LOGS/{combo}/indexfa.log", combo=combo)
+    log:    expand("LOGS/{combo}/MAPPING/samtools/indexfa.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
@@ -16,7 +16,7 @@ rule UnzipGenome_no_us:
     output: fa = expand("{ref}_us.fa", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fai = expand("{ref}_us.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
             fas = expand("{ref}_us.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
-    log:    expand("LOGS/{combo}/indexfa_us.log", combo=combo)
+    log:    expand("LOGS/{combo}/MAPPING/samtools/indexfa_us.log", combo=combo)
     conda:  "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: 1
diff --git a/workflows/mapping.nf b/workflows/mapping.nf
index b455eba4..fc4077be 100644
--- a/workflows/mapping.nf
+++ b/workflows/mapping.nf
@@ -42,7 +42,7 @@ process sam2bam{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
 
@@ -73,7 +73,7 @@ process uniqsam{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("unique.sam.gz") > 0)   "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.sam.gz"
-        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)       "LOGS/${COMBO}/${CONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
 
@@ -109,7 +109,7 @@ process sam2bamuniq{
     saveAs: {filename ->
         if (filename.endsWith(".bam"))       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam"
         else if (filename.indexOf(".bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.bam.bai"
-        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") > 0)  "LOGS/${COMBO}/${CONDITION}/MAPPING/samtools/${file(filename).getSimpleName()}.log"
         else null
     }
 
diff --git a/workflows/mapping.smk b/workflows/mapping.smk
index cd95c43b..138e3707 100644
--- a/workflows/mapping.smk
+++ b/workflows/mapping.smk
@@ -3,7 +3,7 @@ rule sortsam:
     output: sortedsam = report("MAPPED/{combo}/{file}_mapped_sorted.sam.gz", category="SORTING"),
             tmphead = temp("MAPPED/{combo}/{file}_mapped_header.gz"),
             tmpfile = temp("TMP/{combo}/{file}")
-    log:    "LOGS/{combo}/{file}/sortsam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sortsam.log"
     conda: "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -16,7 +16,7 @@ rule sam2bam:
     input:  sortedsam = rules.sortsam.output.sortedsam
     output: bam = report("MAPPED/{combo}/{file}_mapped_sorted.bam", category="2BAM"),
             bamindex = "MAPPED/{combo}/{file}_mapped_sorted.bam.bai"
-    log:    "LOGS/{combo}/{file}/sam2bam.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/samtools/sam2bam.log"
     conda: "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -27,7 +27,7 @@ rule uniqsam:
     input:  sortedsam = rules.sortsam.output.sortedsam,
             bam = rules.sam2bam.output
     output: uniqsam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.sam.gz", category="UNIQUE")
-    log: "LOGS/{combo}/{file}/uniqsam.log"
+    log: "LOGS/{combo}/{file}/MAPPING/samtools/uniqsam.log"
     conda: "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
@@ -39,7 +39,7 @@ rule sam2bamuniq:
            bam = rules.sam2bam.output
     output:  uniqbam = report("MAPPED/{combo}/{file}_mapped_sorted_unique.bam", category="2BAM"),
              uniqbamindex = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
-    log:     "LOGS/{combo}/{file}/sam2bamuniq.log"
+    log:     "LOGS/{combo}/{file}/MAPPING/samtools/sam2bamuniq.log"
     conda:   "samtools.yaml"
     container: "oras://jfallmann/monsda:samtools"
     threads: MAXTHREAD
diff --git a/workflows/minimap.nf b/workflows/minimap.nf
index 7313a28b..59289db3 100644
--- a/workflows/minimap.nf
+++ b/workflows/minimap.nf
@@ -39,7 +39,7 @@ process minimap_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "minimap.idx")                  "$MAPIDX"
-        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/minimap_index.log"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/minimap/index.log"
         else                                            "$MAPUIDX"
     }
 
@@ -70,7 +70,7 @@ process minimap_mapping{
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_trimmed/,"")}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/minimap/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/minimap.smk b/workflows/minimap.smk
index 3e085874..237a225c 100644
--- a/workflows/minimap.smk
+++ b/workflows/minimap.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/minimap/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -40,7 +40,7 @@ else:
                 uidx = rules.generate_index.output.uidx[0]
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/minimap/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/multiqc.nf b/workflows/multiqc.nf
index f51c1c0d..601ca4c6 100644
--- a/workflows/multiqc.nf
+++ b/workflows/multiqc.nf
@@ -28,30 +28,34 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${COMBO}/${CONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${COMBO}"
     CONDITION_VAL="${CONDITION}"
+    mkdir -p "\$COLLECT"
 
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
 
-    # If this is a rustqc combo and the corresponding fastqc combo exists,
-    # include the fastqc output directory in the same MultiQC report.
-    if [[ "\$COMBO_VAL" == *"rustqc"* ]]; then
-        FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-        FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-        if [[ -d "\$FQ_DIR" ]]; then
-            echo "\$FQ_DIR" >> "\$LIST"
-        fi
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
+    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
     fi
 
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 
diff --git a/workflows/multiqc.smk b/workflows/multiqc.smk
index 315af405..eccae6ec 100644
--- a/workflows/multiqc.smk
+++ b/workflows/multiqc.smk
@@ -11,16 +11,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -31,16 +32,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         if prededup:
@@ -54,16 +56,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"])  
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -74,16 +77,17 @@ if rundedup:
                         expand(rules.qc_uniquededup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
-                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"])
+                        expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
+                        versions = "LOGS/versions.txt"
                 output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                         tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                         lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-                log:    "LOGS/{combo}/{condition}_multiqc.log"
+                log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     if paired == 'paired':
@@ -93,16 +97,17 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda:  "qc.yaml"
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         rule multiqc:
@@ -111,13 +116,14 @@ else:
                     expand(rules.qc_mapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.qc_uniquemapped.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                    expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                    versions = "LOGS/versions.txt"
             output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                     tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                     lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-            log:    "LOGS/{combo}/{condition}_multiqc.log"
+            log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda:  "qc.yaml"
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/multiqc_rustqc.nf b/workflows/multiqc_rustqc.nf
index 71cfe752..047e794d 100644
--- a/workflows/multiqc_rustqc.nf
+++ b/workflows/multiqc_rustqc.nf
@@ -28,27 +28,34 @@ process mqc{
     """
     touch $others
     OUT=\${PWD}
-    LIST=multiqc_inputs.txt
-    TMP_LIST=multiqc_inputs_unique.txt
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${COMBO}/${CONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${COMBO}"
     CONDITION_VAL="${CONDITION}"
+    mkdir -p "\$COLLECT"
 
     for i in $others; do
-        dirname "\$i" >> "\$LIST"
+        cp -f "\$i" "\$COLLECT"/
     done
 
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
     FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
     FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ -d "\$FQ_DIR" ]]; then
-        echo "\$FQ_DIR" >> "\$LIST"
+    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
+        EXTRA="\$FQ_DIR"
     fi
 
-    sort -u "\$LIST" > "\$TMP_LIST"
-    export LC_ALL=en_US.utf8
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
     export LC_ALL=C.UTF-8
-    multiqc -f --exclude picard --exclude gatk -k json -z -s -o "\$OUT" -l "\$TMP_LIST"
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 
diff --git a/workflows/multiqc_rustqc.smk b/workflows/multiqc_rustqc.smk
index 17022c50..93ab506f 100644
--- a/workflows/multiqc_rustqc.smk
+++ b/workflows/multiqc_rustqc.smk
@@ -3,29 +3,31 @@ if paired == 'paired':
         input:  expand(rules.rustqc_mapped.output.js, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.rustqc_uniquemapped.output.js, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                versions = "LOGS/versions.txt"
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input}; do echo $(dirname \"${{i}}\") >> {output.tmp}; done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; fi; cat {output.tmp} | sort -u > {output.lst}; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o ${{OUT}} -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
         input:  expand(rules.rustqc_mapped.output.js, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.rustqc_uniquemapped.output.js, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
-                expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo)
+                expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
+                versions = "LOGS/versions.txt"
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input}; do echo $(dirname \"${{i}}\") >> {output.tmp}; done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; fi; cat {output.tmp} | sort -u > {output.lst}; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o ${{OUT}} -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/multx.smk b/workflows/multx.smk
index b65cff5c..855ac2dd 100644
--- a/workflows/multx.smk
+++ b/workflows/multx.smk
@@ -14,7 +14,7 @@ if paired == 'paired':
             unmatched_r1 = temp("FASTQ/{combo}/{file}_unmatched_R1.fastq.gz"),
             unmatched_r2 = temp("FASTQ/{combo}/{file}_unmatched_R2.fastq.gz")
         log:
-            "LOGS/{combo}/{file}_multx_first.log"
+            "LOGS/{combo}/{file}/TRIMMING/multx/multx_first.log"
         conda: ""+MULTXENV+".yaml"
         container: "oras://jfallmann/monsda:"+MULTXENV+""
         threads: MAXTHREAD
@@ -45,7 +45,7 @@ if paired == 'paired':
             o1 = temp("FASTQ/{combo}/{file}_R1_demux_second.fastq.gz"),
             o2 = temp("FASTQ/{combo}/{file}_R2_demux_second.fastq.gz")
         log:
-            "LOGS/{combo}/{file}_multx_second.log"
+            "LOGS/{combo}/{file}/TRIMMING/multx/multx_second.log"
         conda: ""+MULTXENV+".yaml"
         container: "oras://jfallmann/monsda:"+MULTXENV+""
         threads: MAXTHREAD
diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
index 5678bcda..4cbb0f4c 100644
--- a/workflows/oarfish.nf
+++ b/workflows/oarfish.nf
@@ -17,7 +17,7 @@ process oarfish_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/oarfish/${file(filename).getName()}"
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/oarfish.smk b/workflows/oarfish.smk
index dc40b078..58ec0c9b 100644
--- a/workflows/oarfish.smk
+++ b/workflows/oarfish.smk
@@ -14,7 +14,7 @@ rule mapping:
             fa = REFERENCE
     output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
             ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-    log:    "LOGS/{combo}/{file}/oarfishquant.log"
+    log:    "LOGS/{combo}/{file}/COUNTING/oarfish/oarfishquant.log"
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
diff --git a/workflows/peaks.nf b/workflows/peaks.nf
index 30c32ceb..dfd0b179 100644
--- a/workflows/peaks.nf
+++ b/workflows/peaks.nf
@@ -20,7 +20,7 @@ process BamToBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -57,7 +57,7 @@ process ExtendBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -99,7 +99,7 @@ process BedToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bedtobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/peaks/${file(filename).getName()}_bedtobedgraph.log"
     }
 
     input:
@@ -134,7 +134,7 @@ process PreprocessPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/prepeak_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/prepeak_${file(filename).getName()}.log"
     }
 
     input:
@@ -164,7 +164,7 @@ process FindPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -195,7 +195,7 @@ process PeakToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/${file(filename).getName()}_peaktobedgraph.log"
     }
 
     input:
@@ -232,7 +232,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/peaks/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -266,7 +266,7 @@ process PeakToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/peaks/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -301,7 +301,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/PEAKS/${file(filename).getName()}"
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/peaks/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/peaks.smk b/workflows/peaks.smk
index 92853292..ce478bd3 100644
--- a/workflows/peaks.smk
+++ b/workflows/peaks.smk
@@ -50,7 +50,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/peaks/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -61,7 +61,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/peaks/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -74,7 +74,7 @@ rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/peaks/extendbed_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -85,7 +85,7 @@ rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_revextend_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/peaks/revextend_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -99,7 +99,7 @@ if IP == 'iCLIP':
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/{file}bed2bedgraph_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -114,7 +114,7 @@ elif IP == 'revCLIP':
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -129,7 +129,7 @@ else:
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -141,7 +141,7 @@ else:
 rule PreprocessPeaks:
     input:  bedg = rules.BedToBedg.output.concat
     output: pre = "PEAKS/{combo}/{file}_prepeak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/prepeak_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/prepeak_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -153,7 +153,7 @@ rule PreprocessPeaks:
 rule FindPeaks:
     input:  pre = "PEAKS/{combo}/{file}_prepeak_{type}.bed.gz"
     output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_findpeaks_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/findpeaks_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -177,7 +177,7 @@ rule AddSequenceToPeak:
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
-    log:    "LOGS/PEAKS/{combo}/seq2peaks_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/seq2peaks_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -189,7 +189,7 @@ if ANNOPEAK is not None:
     rule AnnotatePeak:
         input:  "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz"
         output: "PEAKS/{combo}/{file}_peak_anno_{type}.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/{file}annotatepeaks_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/annotatepeaks_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -205,7 +205,7 @@ if ANNOPEAK is not None:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -221,7 +221,7 @@ else:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/peaks/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -235,7 +235,7 @@ rule NormalizeBedg:
             re = rules.PeakToBedg.output.re
     output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.norm.bedg.gz",
             re = "PEAKS/{combo}/{file}_peak_{type}.re.norm.bedg.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_peaknormalizebedgraph_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/peaknormalizebedgraph_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -252,7 +252,7 @@ rule PeakToTRACKS:
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
             tre = temp("TRACKS/PEAKS/{combo}/{file}_{type}re_tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_peak2ucsc_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/peak2ucsc_{type}.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -263,7 +263,7 @@ rule GenerateTrack:
             re = rules.PeakToTRACKS.output.re
     output: "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw.trackdone"
-    log:    "LOGS/PEAKS/{combo}/{file}_generatetrack_{type}_peak.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/peaks/generatetrack_{type}_peak.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/picard_dedup.nf b/workflows/picard_dedup.nf
index 984beff4..d9423672 100644
--- a/workflows/picard_dedup.nf
+++ b/workflows/picard_dedup.nf
@@ -14,11 +14,13 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))              "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0)  "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)       "LOGS/${COMBO}/${CONDITION}/DEDUP/picard/${file(filename).getName()}"
         else if (filename.indexOf("metrix.txt") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else null
     }
 
+    publishDir "${workflow.workDir}/../LOGS/${COMBO}/${CONDITION}/DEDUP/picard" , mode: 'copy', pattern: "*_dedup_metrix.txt"
+
     input:
     path todedup
     path bami
diff --git a/workflows/picard_dedup.smk b/workflows/picard_dedup.smk
index 535a5f08..0cbd9f4f 100644
--- a/workflows/picard_dedup.smk
+++ b/workflows/picard_dedup.smk
@@ -6,7 +6,7 @@ rule dedupbam:
             bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
             met = report("MAPPED/{combo}/{file}_mapped_{type}_dedup_metrics.txt", category="DEDUP"),
             td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-    log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+    log:    "LOGS/{combo}/{file}/DEDUP/picard/dedupbam_{type}.log"
     conda:  ""+DEDUPENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEDUPENV+""
     threads: 1
@@ -14,4 +14,4 @@ rule dedupbam:
     params: jpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('JAVA', ""),
             dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('DEDUP', ""),
             dedup = DEDUPBIN
-    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log}"
\ No newline at end of file
+    shell: "mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/"
\ No newline at end of file
diff --git a/workflows/piranha.nf b/workflows/piranha.nf
index 7e8098f3..34c718c7 100644
--- a/workflows/piranha.nf
+++ b/workflows/piranha.nf
@@ -21,7 +21,7 @@ process BamToBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -58,7 +58,7 @@ process ExtendBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -100,7 +100,7 @@ process BedToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bedtobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/piranha/${file(filename).getName()}_bedtobedgraph.log"
     }
 
     input:
@@ -135,7 +135,7 @@ process PreprocessPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/prepeak_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/prepeak_${file(filename).getName()}.log"
     }
 
     input:
@@ -165,7 +165,7 @@ process FindPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -196,7 +196,7 @@ process PeakToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/${file(filename).getName()}_peaktobedgraph.log"
     }
 
     input:
@@ -233,7 +233,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/piranha/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -267,7 +267,7 @@ process PeakToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/piranha/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -302,7 +302,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/PEAKS/${file(filename).getName()}"
-        else if (filename == ".log")        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/piranha/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/piranha.smk b/workflows/piranha.smk
index 3ecd7001..410136e7 100644
--- a/workflows/piranha.smk
+++ b/workflows/piranha.smk
@@ -50,7 +50,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/piranha/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -61,7 +61,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/piranha/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -74,7 +74,7 @@ rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/piranha/extendbed_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -85,7 +85,7 @@ rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_revextendbed_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/piranha/revextendbed_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -99,7 +99,7 @@ if IP == 'iCLIP':
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/{file}bed2bedgraph_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -114,7 +114,7 @@ elif IP == 'revCLIP':
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -129,7 +129,7 @@ else:
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: concat = "PEAKS/{combo}/{file}_mapped_{type}.bedg.gz",
                 tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-        log:    "LOGS/PEAKS/{combo}/bed2bedgraph_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/bed2bedgraph_{type}.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -142,7 +142,7 @@ else:
 rule PreprocessPeaks:
     input:  bedg = rules.BedToBedg.output.concat
     output: pre = "PEAKS/{combo}/{file}_prepeak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/prepeak_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/prepeak_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -153,7 +153,7 @@ rule PreprocessPeaks:
 rule FindPeaks:
     input:  pre = rules.PreprocessPeaks.output.pre
     output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/findpeaks_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/findpeaks_{type}.log"
     conda:  ""+PEAKENV+".yaml"
     container: "oras://jfallmann/monsda:"+PEAKENV+""
     threads: 1
@@ -168,7 +168,7 @@ rule AddSequenceToPeak:
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
-    log:    "LOGS/PEAKS/{combo}/seq2peaks_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/seq2peaks_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -180,7 +180,7 @@ if ANNOPEAK is not None:
     rule AnnotatePeak:
         input:  "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz"
         output: "PEAKS/{combo}/{file}_peak_anno_{type}.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/annotatepeaks_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/annotatepeaks_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -196,7 +196,7 @@ if ANNOPEAK is not None:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 trw = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -212,7 +212,7 @@ else:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/piranha/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -226,7 +226,7 @@ rule NormalizeBedg:
             re = rules.PeakToBedg.output.re
     output: fw = "PEAKS/{combo}/{file}_peak_{type}.fw.norm.bedg.gz",
             re = "PEAKS/{combo}/{file}_peak_{type}.re.norm.bedg.gz"
-    log:    "LOGS/PEAKS/{combo}/ucscpeaknormalizebedgraph_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/ucscpeaknormalizebedgraph_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -243,7 +243,7 @@ rule PeakToTRACKS:
             re = "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw",
             tfw = temp("TRACKS/PEAKS/{combo}/{file}_{type}fw_tmp"),
             tre = temp("TRACKS/PEAKS/{combo}/{file}_{type}re_tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_peak2ucsc_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/peak2ucsc_{type}.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -255,7 +255,7 @@ rule GenerateTrack:
             re = rules.PeakToTRACKS.output.re
     output: "TRACKS/PEAKS/{combo}/{file}_peak_{type}.fw.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_peak_{type}.re.bw.trackdone"
-    log:    "LOGS/PEAKS/{combo}/generatetrack_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/piranha/generatetrack_{type}.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/piscem.nf b/workflows/piscem.nf
index 830f68ba..a471caab 100644
--- a/workflows/piscem.nf
+++ b/workflows/piscem.nf
@@ -37,7 +37,7 @@ process piscem_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "piscem.idx")                  "$MAPIDX"
-        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/piscem_index.log"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/piscem/index.log"
         else                                            "$MAPUIDXNAME"
     }
 
@@ -65,7 +65,7 @@ process piscem_mapping{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
-        if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/piscem/${file(filename).getName()}"
         else                                       "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/piscem.smk b/workflows/piscem.smk
index ba001850..4edce369 100644
--- a/workflows/piscem.smk
+++ b/workflows/piscem.smk
@@ -11,7 +11,7 @@ rule generate_index:
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik)),
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.sshash", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -28,7 +28,7 @@ rule mapping:
             dummy = rules.generate_index.output.idxfile
     output: rad = directory("MAPPED/{combo}/{file}"),
             radfile = "MAPPED/{combo}/{file}/map.rad"
-    log:    "LOGS/{combo}/{file}/mapping.log"
+    log:    "LOGS/{combo}/{file}/MAPPING/piscem/mapping.log"
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
diff --git a/workflows/premultiqc.nf b/workflows/premultiqc.nf
index cce8b65b..9a878187 100644
--- a/workflows/premultiqc.nf
+++ b/workflows/premultiqc.nf
@@ -39,7 +39,24 @@ process premultiqc{
 
     script:
     """
-    export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f --exclude picard --exclude gatk -k json -z -s 
+    OUT=\${PWD}
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${CONDITION}"
+    COLLECT="\${SCAN}/MULTIQC/collect"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    mkdir -p "\$COLLECT"
+
+    for i in $samples; do
+        cp -f "\$i" "\$COLLECT"/
+    done
+
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
+    export LC_ALL=C.UTF-8
+    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN"
     """
 }
 
@@ -50,7 +67,7 @@ workflow PREMULTIQC{
     main:
 
     //SAMPLE CHANNELS
-    multiqc(otherqcs.collect())
+    premultiqc(otherqcs.collect())
 
     emit:
     mqcres = premultiqc.out.multiqc_results
diff --git a/workflows/premultiqc.smk b/workflows/premultiqc.smk
index 74c100e3..8225b9ec 100644
--- a/workflows/premultiqc.smk
+++ b/workflows/premultiqc.smk
@@ -4,23 +4,25 @@ rule qcall:
 if paired == 'paired':
     rule multiqc:
         input: expand("QC/{rawfile}_{read}_fastqc.zip", rawfile=list(SAMPLES), read=['R1','R2']),
+               versions = "LOGS/versions.txt"
         output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{condition}/tmp"),
                 lst = "QC/Multi/{condition}/qclist.txt"
-        log:    "LOGS/{condition}/multiqc.log"
+        log:    "LOGS/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
         input: expand("QC/{rawfile}_fastqc.zip", rawfile=list(SAMPLES)),
+               versions = "LOGS/versions.txt"
         output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{condition}/tmp"),
                 lst = "QC/Multi/{condition}/qclist.txt"
-        log:    "LOGS/{condition}/multiqc.log"
+        log:    "LOGS/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/rammap.nf b/workflows/rammap.nf
index 41561a02..4ea7b7bf 100644
--- a/workflows/rammap.nf
+++ b/workflows/rammap.nf
@@ -24,7 +24,7 @@ process rammap_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "rammap.idx")                  "$MAPIDX"
-        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/rammap_index.log"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/rammap/index.log"
         else                                            "$MAPUIDX"
     }
 
@@ -53,7 +53,7 @@ process rammap_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/rammap/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/rammap.smk b/workflows/rammap.smk
index 115eb248..cce02da8 100644
--- a/workflows/rammap.smk
+++ b/workflows/rammap.smk
@@ -10,7 +10,7 @@ rule generate_index:
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -27,7 +27,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/rammap/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -41,7 +41,7 @@ else:
                 uidx = rules.generate_index.output.uidx[0]
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/rammap/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/rastqc.smk b/workflows/rastqc.smk
index 2880caeb..42dadf2d 100644
--- a/workflows/rastqc.smk
+++ b/workflows/rastqc.smk
@@ -5,7 +5,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -27,7 +27,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -50,7 +50,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -61,7 +61,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -72,7 +72,7 @@ else:
 rule qc_mapped:
     input:   r1 = "MAPPED/{combo}/{file}_mapped_sorted.bam"
     output:  o1 = report("QC/{combo}/{file}_mapped_sorted_fastqc.zip", category="QC")
-    log:     "LOGS/{combo}/{file}_fastqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/rastqc/fastqc_mapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -83,7 +83,7 @@ rule qc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_uniquemapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -94,7 +94,7 @@ rule qc_dedupmapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_dedupmapped.log"
+    log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_dedupmapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -105,7 +105,7 @@ rule qc_uniquededup:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam",
             r2 = "MAPPED/{combo}/{file}_mapped_sorted_unique_dedup.bam.bai"
     output: o1 = report("QC/{combo}/{file}_mapped_sorted_unique_dedup_fastqc.zip", category="QC")
-    log:    "LOGS/{combo}/{file}_fastqc_uniquededup.log"
+    log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_uniquededup.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
diff --git a/workflows/rastqc_dedup.smk b/workflows/rastqc_dedup.smk
index 6aa8e25c..01b9c5a0 100644
--- a/workflows/rastqc_dedup.smk
+++ b/workflows/rastqc_dedup.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -50,7 +50,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -60,7 +60,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -73,7 +73,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/rastqc_dedup_trim.smk b/workflows/rastqc_dedup_trim.smk
index f76b5dc0..1fb52a12 100644
--- a/workflows/rastqc_dedup_trim.smk
+++ b/workflows/rastqc_dedup_trim.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_{read}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -36,7 +36,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -50,7 +50,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -61,7 +61,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -71,7 +71,7 @@ else:
     rule qc_dedup:
         input:  r1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_dedup_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_dedup.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -81,7 +81,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -95,7 +95,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trim_dedup.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/rastqc_raw.smk b/workflows/rastqc_raw.smk
index d6e94c30..48400866 100644
--- a/workflows/rastqc_raw.smk
+++ b/workflows/rastqc_raw.smk
@@ -5,7 +5,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -17,7 +17,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -28,7 +28,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -40,7 +40,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/rastqc_trim.smk b/workflows/rastqc_trim.smk
index e6f2634e..253bf1a1 100644
--- a/workflows/rastqc_trim.smk
+++ b/workflows/rastqc_trim.smk
@@ -16,7 +16,7 @@ if paired == 'paired':
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}_{read}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_{read}_fastqc.zip")
-        log:    "LOGS/{combo}/{rawfile}_fastqc_{read}_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_{read}_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -26,7 +26,7 @@ if paired == 'paired':
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_{read}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_{read}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/{combo}/{file}_{read}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/{read}_fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -39,7 +39,7 @@ if paired == 'paired':
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
@@ -50,7 +50,7 @@ else:
     rule qc_raw:
         input:  r1 = "FASTQ/{rawfile}.fastq.gz"
         output: o1 = report("QC/{combo}/{rawfile}_fastqc.zip", category="QC")
-        log:    "LOGS/QC/{combo}/{rawfile}_fastqc_raw.log"
+        log:    "LOGS/{combo}/{rawfile}/QC/rastqc/fastqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -60,7 +60,7 @@ else:
     rule qc_trimmed:
         input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz"
         output: o1 = report("QC/{combo}/{file}_trimmed_fastqc.zip", category="QC")
-        log:    "LOGS/QC/{combo}/{file}_fastqc_trimmed.log"
+        log:    "LOGS/{combo}/{file}/QC/rastqc/fastqc_trimmed.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: MAXTHREAD
@@ -73,7 +73,7 @@ else:
         output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
                 tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
                 lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
-        log:    "LOGS/{combo}/{condition}_multiqc_trimmed_raw.log"
+        log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
diff --git a/workflows/rustar.nf b/workflows/rustar.nf
index 11bd3d36..b15427ad 100644
--- a/workflows/rustar.nf
+++ b/workflows/rustar.nf
@@ -37,7 +37,7 @@ process rustar_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/rustar_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/star/rustar_index.log"
         else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
         else                                             "$MAPUIDX"
     }
@@ -72,8 +72,8 @@ process rustar_mapping{
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)     "MAPPED/${COMBO}/${CONDITION}/"+"${filename.replaceAll(/\Q.Aligned.out.sam.gz\E/,"")}_mapped.sam.gz"
-        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star/rustar_"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
         else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
     }
diff --git a/workflows/rustar.smk b/workflows/rustar.smk
index 6a094b5d..2b478fb5 100644
--- a/workflows/rustar.smk
+++ b/workflows/rustar.smk
@@ -12,7 +12,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}/ref.fa", mape=MAPPERENV)),
             tmpref = temp(expand("TMP/{mape}/ref.anno", mape=MAPPERENV))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -33,10 +33,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -56,10 +56,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -79,10 +79,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
diff --git a/workflows/rustqc.smk b/workflows/rustqc.smk
index 44695448..f8dafa0b 100644
--- a/workflows/rustqc.smk
+++ b/workflows/rustqc.smk
@@ -17,7 +17,7 @@ rule rustqc_mapped:
     output:  o1 = directory("QC/{combo}/{file}_mapped_sorted"),
              js = "QC/{combo}/{file}_mapped_sorted/rustqc_summary.json",
              tmpanno = temp("TMP/QC/{combo}/{file}_ms_anno.gtf")
-    log:     "LOGS/{combo}/{file}_rustqc_mapped.log"
+    log:     "LOGS/{combo}/{file}/QC/rustqc/rustqc_mapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
@@ -33,7 +33,7 @@ rule rustqc_uniquemapped:
     output: o1 = directory("QC/{combo}/{file}_mapped_sorted_unique"),
         js = "QC/{combo}/{file}_mapped_sorted_unique/rustqc_summary.json",
         tmpanno = temp("TMP/QC/{combo}/{file}_msu_anno.gtf")
-    log:    "LOGS/{combo}/{file}_rustqc_uniquemapped.log"
+    log:    "LOGS/{combo}/{file}/QC/rustqc/rustqc_uniquemapped.log"
     conda:  ""+QCENV+".yaml"
     container: "oras://jfallmann/monsda:"+QCENV+""
     threads: MAXTHREAD
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index c75b3dd0..1c0250ab 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -66,7 +66,7 @@ process salmon_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
         if (filename == "salmon.idx")            "$COUNTIDX"
-        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/salmon_index.log"
+        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/salmon/index.log"
         else                                      "$COUNTUIDX"
     }
 
@@ -98,7 +98,7 @@ process salmon_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/salmon/${file(filename).getName()}"
 
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
@@ -161,7 +161,7 @@ process salmon_quant_bam{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/salmon/${file(filename).getName()}"
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/salmon.smk b/workflows/salmon.smk
index afd8ba11..c9e01007 100644
--- a/workflows/salmon.smk
+++ b/workflows/salmon.smk
@@ -14,7 +14,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -31,7 +31,7 @@ if bammode == 'transcriptome':
                 fa = REFERENCE
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -48,7 +48,7 @@ elif bammode == 'genome':
                 fa = REFERENCE
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -63,7 +63,7 @@ elif paired == 'paired':
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -79,7 +79,7 @@ else:
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
diff --git a/workflows/salmon_trim.smk b/workflows/salmon_trim.smk
index ffce1c47..67e0e144 100644
--- a/workflows/salmon_trim.smk
+++ b/workflows/salmon_trim.smk
@@ -10,8 +10,8 @@ rule themall:
 
 if paired == 'paired':
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_R1_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file),
+                r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_R2_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_R1_trimmed.fastq.gz",
                 r2 = "TRIMMED_FASTQ/{scombo}/{file}_R2_trimmed.fastq.gz"
         threads: 1
@@ -21,7 +21,7 @@ if paired == 'paired':
 
 else:
     rule simulate_trim:
-        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
+        input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{scombo}/{file}_dedup.fastq.gz".format(scombo=scombo, file=wildcards.file)
         output: r1 = "TRIMMED_FASTQ/{scombo}/{file}_trimmed.fastq.gz"
         threads: 1
         params: filetolink = lambda w, input: "{r}".format(r=os.path.abspath(input.r1))
@@ -31,7 +31,7 @@ rule salmon_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=COUNTENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{cape}.idx.log", sets=SETS, cape=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cape}/idx.log", sets=SETS, cape=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -48,7 +48,7 @@ if paired == 'paired':
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
@@ -65,7 +65,7 @@ else:
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/salmonquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/salmon/salmonquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
diff --git a/workflows/salmonalign.nf b/workflows/salmonalign.nf
index 7ec05eb3..e92bb561 100644
--- a/workflows/salmonalign.nf
+++ b/workflows/salmonalign.nf
@@ -26,7 +26,7 @@ process salmonalign_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
         if (filename == "salmonalign.idx")              "$MAPIDX"
-        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/salmonalign_index.log"
+        else if (filename.indexOf("index.log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/salmon/salmonalign_index.log"
         else                                            "$MAPUIDX"
     }
 
@@ -55,7 +55,7 @@ process salmonalign_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/salmon/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/salmonalign.smk b/workflows/salmonalign.smk
index b298f74a..2c6c5513 100644
--- a/workflows/salmonalign.smk
+++ b/workflows/salmonalign.smk
@@ -10,7 +10,7 @@ rule generate_index:
     input:  fa = REFERENCE
     output: idx = directory(INDEX),
             uidx = directory(expand("{refd}/INDICES/{mape}_{unikey}", refd=REFDIR, mape=MAPPERENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERYAML+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERYAML+""
     threads: MAXTHREAD
@@ -28,7 +28,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/salmon/mapping.log"
         conda:  ""+MAPPERYAML+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERYAML+""
         threads: MAXTHREAD
@@ -44,7 +44,7 @@ else:
                 uidx = rules.generate_index.output.uidx[0]
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/salmon/mapping.log"
         conda:  ""+MAPPERYAML+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERYAML+""
         threads: MAXTHREAD
diff --git a/workflows/scyphy.nf b/workflows/scyphy.nf
index 82dc487a..5273df4e 100644
--- a/workflows/scyphy.nf
+++ b/workflows/scyphy.nf
@@ -22,7 +22,7 @@ process RemoveSoftclip{
     saveAs: {filename ->
         if (filename.indexOf(".bam.bai") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"                
         else if (filename.indexOf(".bam") > 0)      "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf("log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_removeSoftclip.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_removeSoftclip.log"
     }
 
     input:
@@ -55,7 +55,7 @@ process BamToBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/\Q_ext.bed.gz\E/,".bed.gz")}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -95,7 +95,7 @@ process ExtendBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${COMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -132,7 +132,7 @@ process RevExtendBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${COMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -170,7 +170,7 @@ process BedToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscbedtobedgraph.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_ucscbedtobedgraph.log"
     }
 
     input:
@@ -221,7 +221,7 @@ process BedToBedgPeak{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscbedtobedgraph.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_ucscbedtobedgraph.log"
     }
 
     input:
@@ -271,7 +271,7 @@ process PreprocessPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/prepeak_${file(filename).getName()}.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/prepeak_${file(filename).getName()}.log"
     }
 
     input:
@@ -302,7 +302,7 @@ process FindPeaks{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -332,7 +332,7 @@ process AddSequenceToPeak{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/findpeaks_${file(filename).getName()}.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/findpeaks_${file(filename).getName()}.log"
     }
 
     input:
@@ -364,7 +364,7 @@ process PeakToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktobedgraph.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_peaktobedgraph.log"
     }
 
     input:
@@ -401,7 +401,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -435,7 +435,7 @@ process NormalizePeakBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/PEAKS/scyphy/${file(filename).getName()}_ucscpeaknormalizebedgraph.log"
     }
 
     input:
@@ -469,7 +469,7 @@ process PeakToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/scyphy/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -504,7 +504,7 @@ process BedgToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_peaktoucsc.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/scyphy/${file(filename).getName()}_peaktoucsc.log"
     }
 
     input:
@@ -540,7 +540,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/PEAKS/${file(filename).getName()}"
-        else if (filename.indexOf(".log") > 0)        "LOGS/TRACKS/PEAKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/scyphy/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/scyphy.smk b/workflows/scyphy.smk
index 7ed79514..d6580894 100644
--- a/workflows/scyphy.smk
+++ b/workflows/scyphy.smk
@@ -63,7 +63,7 @@ if not all(checklist):
                 refi = expand("{ref}.fa.fai", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa')),
         output: bam = "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam",
                 bai = "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam.bai"
-        log:    "LOGS/PEAKS/{scombo}/{file}_removesoftclip_{type}.log"
+        log:    "LOGS/{scombo}/{file}/PEAKS/scyphy/removesoftclip_{type}.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:scyphy"
         threads: 1
@@ -76,7 +76,7 @@ if not all(checklist):
         rule BamToBed:
             input:  "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam",
             output: "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/scyphy/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -87,7 +87,7 @@ if not all(checklist):
         rule BamToBed:
             input:  "MAPPED/{scombo}/{file}_mapped_{type}_nosoftclip.bam",
             output: "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/PEAKS/scyphy/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -99,7 +99,7 @@ rule extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_extended_{type}_nosoftclip.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_extendbed_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/scyphy/extendbed_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -110,7 +110,7 @@ rule rev_extendbed:
     input:  pks = "BED/{scombo}/{file}_mapped_{type}_nosoftclip.bed.gz",
             ref = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
     output: ext = "BED/{scombo}/{file}_mapped_revtrimmed_{type}_nosoftclip.bed.gz"
-    log:    "LOGS/PEAKS/{scombo}/{file}_revextendbed_{type}.log"
+    log:    "LOGS/{scombo}/{file}/PEAKS/scyphy/revextendbed_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -125,7 +125,7 @@ rule BedToBedg_ext:
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_ext.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_ext.bedg.gz",
             tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}_ext.unsrt")
-    log:    "LOGS/PEAKS/{combo}/{file}_bed2bedgraph_ext_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/bed2bedgraph_ext_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -142,7 +142,7 @@ rule BedToBedg_rev:
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_rev.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip_rev.bedg.gz",
             tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}_rev.unsrt")
-    log:    "LOGS/PEAKS/{combo}/{file}_bed2bedgraph_rev_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/bed2bedgraph_rev_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -159,7 +159,7 @@ rule BedToBedg:
             concat_re = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip.re.bedg.gz",
             concat = "PEAKS/{combo}/{file}_mapped_{type}_nosoftclip.bedg.gz",
             tosrt = temp("PEAKS/{combo}/{file}_mapped_{type}.unsrt")
-    log:    "LOGS/PEAKS/{combo}/{file}_bed2bedgraph_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/bed2bedgraph_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -172,7 +172,7 @@ if any(x == IP for x in ['iCLIP', 'CLIP']):
     rule PreprocessPeaks:
         input:  bedg = rules.BedToBedg_ext.output.concat
         output: pre = "PEAKS/{combo}/{file}_prepeak_{type}_nosoftclip.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/prepeak_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/scyphy/prepeak_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -184,7 +184,7 @@ elif IP == 'revCLIP':
     rule PreprocessPeaks:
         input:  bedg = rules.BedToBedg_rev.output.concat
         output: pre = "PEAKS/{combo}/{file}_prepeak_{type}_nosoftclip.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/prepeak_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/scyphy/prepeak_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -195,7 +195,7 @@ elif IP == 'revCLIP':
 #rule FindPeaks:
 #    input:  pre = rules.PreprocessPeaks.output.pre
 #    output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-#    log:    "LOGS/PEAKS/{combo}/findpeaks_{type}_{file}.log"
+#    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/findpeaks_{type}.log"
 #    conda:  ""+PEAKENV+".yaml"
 #    container: "oras://jfallmann/monsda:"+PEAKENV+""
 #    threads: 1
@@ -207,7 +207,7 @@ elif IP == 'revCLIP':
 rule FindPeaks:
     input:  pre = rules.PreprocessPeaks.output.pre
     output: peak = "PEAKS/{combo}/{file}_peak_{type}.bed.gz"
-    log:    "LOGS/PEAKS/{combo}/{file}_findpeaks_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/findpeaks_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -222,7 +222,7 @@ rule AddSequenceToPeak:
     output: peak = "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz",
             pt = temp("PEAKS/{combo}/{file}_peak_chr_{type}.tmp"),
             ps = temp("PEAKS/{combo}/{file}_peak_seq_{type}.tmp")
-    log:    "LOGS/PEAKS/{combo}/seq2peaks_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/seq2peaks_{type}.log"
     conda:  "bedtools.yaml"
     container: "oras://jfallmann/monsda:bedtools"
     threads: 1
@@ -234,7 +234,7 @@ if ANNOPEAK is not None:
     rule AnnotatePeak:
         input:  "PEAKS/{combo}/{file}_peak_seq_{type}.bed.gz"
         output: "PEAKS/{combo}/{file}_peak_anno_{type}.bed.gz"
-        log:    "LOGS/PEAKS/{combo}/annotatepeaks_{type}_{file}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/scyphy/annotatepeaks_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -250,7 +250,7 @@ if ANNOPEAK is not None:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 trw = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/scyphy/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -266,7 +266,7 @@ else:
                 re = "PEAKS/{combo}/{file}_peak_{type}.re.bedg.gz",
                 tfw = temp("PEAKS/{combo}/{file}_peak_{type}.fw.tmp.gz"),
                 tre = temp("PEAKS/{combo}/{file}_peak_{type}.re.tmp.gz"),
-        log:    "LOGS/PEAKS/{combo}/{file}_peak2bedg_{type}.log"
+        log:    "LOGS/{combo}/{file}/PEAKS/scyphy/peak2bedg_{type}.log"
         conda:  "perl.yaml"
         container: "oras://jfallmann/monsda:perl"
         threads: 1
@@ -292,7 +292,7 @@ rule NormalizeBedg:
             map_re_ext = "PEAKS/{combo}/{file}_mapped_{type}_ext.re.norm.bedg.gz",
             map_fw_rev = "PEAKS/{combo}/{file}_mapped_{type}_rev.fw.norm.bedg.gz",
             map_re_rev = "PEAKS/{combo}/{file}_mapped_{type}_rev.re.norm.bedg.gz"
-    log:    "LOGS/PEAKS/{combo}/ucscpeaknormalizebedgraph_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/ucscpeaknormalizebedgraph_{type}.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -327,7 +327,7 @@ rule PeakToTRACKS:
             tmapre_ext = temp("TRACKS/PEAKS/{combo}/{file}_{type}mapre_ext_tmp"),
             tmapfw_rev = temp("TRACKS/PEAKS/{combo}/{file}_{type}mapfw_rev_tmp"),
             tmapre_rev = temp("TRACKS/PEAKS/{combo}/{file}_{type}mapre_rev_tmp")
-    log:    "LOGS/PEAKS/{combo}/{file}_peak2ucsc_{type}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/peak2ucsc_{type}.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -350,7 +350,7 @@ rule GenerateTrack:
             "TRACKS/PEAKS/{combo}/{file}_mapped_{type}_ext.re.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_mapped_{type}_rev.fw.bw.trackdone",
             "TRACKS/PEAKS/{combo}/{file}_mapped_{type}_rev.re.bw.trackdone"
-    log:    "LOGS/PEAKS/{combo}/generatetrack_{type}_{file}.log"
+    log:    "LOGS/{combo}/{file}/PEAKS/scyphy/generatetrack_{type}.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/segemehl.nf b/workflows/segemehl.nf
index 4a13dfa4..23821e6f 100644
--- a/workflows/segemehl.nf
+++ b/workflows/segemehl.nf
@@ -39,7 +39,7 @@ process segemehl_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
         if (filename == "segemehl.idx")                  "$MAPIDX"
-        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl/${file(filename).getName()}"
         else                                              "$MAPUIDX"
     }
 
@@ -69,7 +69,7 @@ process segemehl_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/segemehl.smk b/workflows/segemehl.smk
index 9bc19472..892b414a 100644
--- a/workflows/segemehl.smk
+++ b/workflows/segemehl.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -27,7 +27,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -42,7 +42,7 @@ else:
                 fa = REFERENCE
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/segemehl3.nf b/workflows/segemehl3.nf
index f486eb37..9082c042 100644
--- a/workflows/segemehl3.nf
+++ b/workflows/segemehl3.nf
@@ -39,7 +39,7 @@ process segemehl3_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
         if (filename == "segemehl3.idx")                  "$MAPIDX"
-        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl3/${file(filename).getName()}"
         else                                              "$MAPUIDX"
     }
 
@@ -71,7 +71,7 @@ process segemehl3_mapping{
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf(".bed") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/\Q_R1\E/,"").replaceAll(/\Q_trimmed.fastq\E/,"")}"
         else if (filename.indexOf(".txt") >0)          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName().replaceAll(/\Q_R1\E/,"").replaceAll(/\Q_trimmed.fastq\E/,"")}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl3/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/segemehl3.smk b/workflows/segemehl3.smk
index ac7f2ff4..11a8e7e7 100644
--- a/workflows/segemehl3.smk
+++ b/workflows/segemehl3.smk
@@ -9,7 +9,7 @@ rule generate_index:
     input:  fa = REFERENCE
     output: idx = INDEX,
             uidx = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik)
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -30,7 +30,7 @@ if paired == 'paired':
                 mult = report("MAPPED/{combo}/{file}.mult.bed", category="MAPPING"),
                 sngl = report("MAPPED/{combo}/{file}.sngl.bed", category="MAPPING"),
                 txt = report("MAPPED/{combo}/{file}.trns.txt", category="MAPPING")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -49,7 +49,7 @@ else:
                 mult = report("MAPPED/{combo}/{file}.mult.bed", category="MAPPING"),
                 sngl = report("MAPPED/{combo}/{file}.sngl.bed", category="MAPPING"),
                 txt = report("MAPPED/{combo}/{file}.trns.txt", category="MAPPING")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
diff --git a/workflows/segemehl3_bisulfite.nf b/workflows/segemehl3_bisulfite.nf
index fec56a8b..20b89a64 100644
--- a/workflows/segemehl3_bisulfite.nf
+++ b/workflows/segemehl3_bisulfite.nf
@@ -43,7 +43,7 @@ process segemehl3_idx{
     saveAs: {filename ->
         if (filename == "segemehl3bisulfite.idx")                  "$MAPIDX"
         else if (filename == "segemehl3bisulfite_bs.idx2")          "$BISIDX"
-        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl3/${file(filename).getName()}"
         else if (filename == "$MAPUIDX2NAME")             "$MAPUIDX2"
         else                                              "$MAPUIDX"
         
@@ -77,7 +77,7 @@ process segemehl3_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl3/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/segemehl3_bisulfite.smk b/workflows/segemehl3_bisulfite.smk
index a1fd848e..2551b9df 100644
--- a/workflows/segemehl3_bisulfite.smk
+++ b/workflows/segemehl3_bisulfite.smk
@@ -11,7 +11,7 @@ rule generate_index:
             idx2 = INDEX2,
             uidx1 = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik),
             uidx2 = expand("{refd}/INDICES/{mape}_{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik+'_bs')
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
     threads: MAXTHREAD
@@ -31,7 +31,7 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
         threads: MAXTHREAD
@@ -46,7 +46,7 @@ else:
                 fa = REFERENCE
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
         threads: MAXTHREAD
diff --git a/workflows/segemehl_bisulfite.nf b/workflows/segemehl_bisulfite.nf
index 55675f4e..33823548 100644
--- a/workflows/segemehl_bisulfite.nf
+++ b/workflows/segemehl_bisulfite.nf
@@ -43,7 +43,7 @@ process segemehl_idx{
     saveAs: {filename ->
         if (filename == "segemehlbisulfite.idx")                  "$MAPIDX"
         else if (filename == "segemehlbisulfite_bs.idx2")          "$BISIDX"
-        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl/${file(filename).getName()}"
         else if (filename == "$MAPUIDX2NAME")             "$MAPUIDX2"
         else                                              "$MAPUIDX"
         
@@ -77,7 +77,7 @@ process segemehl_mapping{
     publishDir "${workflow.workDir}/../" , mode: 'link',
         saveAs: {filename ->
         if (filename.indexOf("_unmapped.fastq.gz") > 0)   "UNMAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)          "LOGS/${COMBO}/${CONDITION}/MAPPING/segemehl/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/segemehl_bisulfite.smk b/workflows/segemehl_bisulfite.smk
index 03c8037d..71233ad4 100644
--- a/workflows/segemehl_bisulfite.smk
+++ b/workflows/segemehl_bisulfite.smk
@@ -11,7 +11,7 @@ rule generate_index:
             idx2 = INDEX2,
             uidx1 = expand("{refd}/INDICES/{mape}_{unikey}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik),
             uidx2 = expand("{refd}/INDICES/{mape}_{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik+'_bs')
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
     threads: MAXTHREAD
@@ -32,7 +32,7 @@ if paired == 'paired':
                 unmapped1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 tmpmap = temp("MAPPED/{combo}/{file}_temp.sam")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
         threads: MAXTHREAD
@@ -49,7 +49,7 @@ else:
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                 tmpmap = temp("MAPPED/{combo}/{file}_temp.sam")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
         threads: MAXTHREAD
diff --git a/workflows/simpleaf.nf b/workflows/simpleaf.nf
index 2e5f92f3..f2eaa3e8 100644
--- a/workflows/simpleaf.nf
+++ b/workflows/simpleaf.nf
@@ -23,7 +23,7 @@ process simpleaf_idx{
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
         if (filename == "simpleaf.idx")            "$COUNTIDX"
-        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/simpleaf_index.log"
+        else if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/COUNTING/simpleaf/index.log"
         else                                      "$COUNTUIDX"
     }
 
@@ -52,7 +52,7 @@ process simpleaf_quant{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/${file(filename).getName()}"
+        if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/COUNTING/simpleaf/${file(filename).getName()}"
         else                                    "COUNTS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/simpleaf.smk b/workflows/simpleaf.smk
index 06a1c38a..cb0465da 100644
--- a/workflows/simpleaf.smk
+++ b/workflows/simpleaf.smk
@@ -15,7 +15,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{cenv}_{unikey}/index/info.json", refd=REFDIR, cenv=COUNTENV, unikey=unik),
             tmpfa = temp(expand("TMP/{cenv}/ref.fa", cenv=COUNTENV)),
             tmpanno = temp(expand("TMP/{cenv}/ref.gtf", cenv=COUNTENV))
-    log:    expand("LOGS/{sets}/{cenv}.idx.log", sets=SETS, cenv=COUNTENV)
+    log:    expand("LOGS/{sets}/COUNTING/{cenv}/idx.log", sets=SETS, cenv=COUNTENV)
     conda:  ""+COUNTENV+".yaml"
     container: "oras://jfallmann/monsda:"+COUNTENV+""
     threads: MAXTHREAD
@@ -32,7 +32,7 @@ if paired == 'paired' or paired == 'singlecell':
                 dummy = rules.generate_index.output.idxfile
         output: cnts = report("COUNTS/{combo}/{file}/af_quant/alevin/quants_mat.mtx.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
-        log:    "LOGS/{combo}/{file}/simpleafquant.log"
+        log:    "LOGS/{combo}/{file}/COUNTING/simpleaf/simpleafquant.log"
         conda:  ""+COUNTENV+".yaml"
         container: "oras://jfallmann/monsda:"+COUNTENV+""
         threads: MAXTHREAD
diff --git a/workflows/spit_DTU.nf b/workflows/spit_DTU.nf
index cf598cb9..76c0f0c8 100644
--- a/workflows/spit_DTU.nf
+++ b/workflows/spit_DTU.nf
@@ -35,7 +35,7 @@ process salmon_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/spit_index.log"
+        if (filename.indexOf(".log") >0)    "LOGS/${COMBO}/${CONDITION}/DTU/spit/index.log"
         else if (filename == "spit.idx")           "$DTUIDX"
         else                                          "$DTUUIDX"
     }
@@ -71,7 +71,7 @@ process prepare_dtu_annotation{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".gz") > 0)       "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
-        else if (filename.indexOf(".log") > 0)        "LOGS/DTU/${SCOMBO}/featurecount_spit_annotation.log"
+        else if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/DTU/spit/featurecount_spit_annotation.log"
     }
 
     output:
@@ -98,7 +98,7 @@ process run_spit{
         if (filename.indexOf("_table") > 0)      "DTU/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DTU/${SCOMBO}/Figures/${file(filename).getName()}" 
         else if (filename.indexOf("SESSION") > 0)      "DTU/${SCOMBO}/${file(filename).getName()}"                     
-        else if (filename.indexOf("log") > 0)        "LOGS/DTU/${SCOMBO}/run_spit.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DTU/spit/run_spit.log"
     }
 
     input:
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
index 4bf7bdb2..d15de3dd 100644
--- a/workflows/spit_DTU.smk
+++ b/workflows/spit_DTU.smk
@@ -42,7 +42,7 @@ rule run_DTU:
             res_i   = rules.themall.input.res_i,
             fig_PV  = rules.themall.input.fig_PV,
             fig_W   = rules.themall.input.fig_W
-    log:    expand("LOGS/DTU/{combo}/run_DTU.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/spit/run_DTU.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
@@ -63,7 +63,7 @@ rule filter_significant_spit:
             sig_t   = rules.themall.input.sig_t,
             sig_dt  = rules.themall.input.sig_dt,
             sig_ut  = rules.themall.input.sig_ut
-    log:    "LOGS/DTU/filter_spitDTU.log"
+    log:    expand("LOGS/{combo}/DTU/spit/filter_spitDTU.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
@@ -85,7 +85,7 @@ rule create_summary_snippet:
             rules.themall.input.sig_ut,
             rules.themall.input.session
     output: rules.themall.input.Rmd
-    log:    expand("LOGS/DTU/{combo}/create_summary_snippet.log", combo=combo)
+    log:    expand("LOGS/{combo}/DTU/spit/create_summary_snippet.log", combo=combo)
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: int(MAXTHREAD-1) if int(MAXTHREAD-1) >= 1 else 1
diff --git a/workflows/sra.nf b/workflows/sra.nf
index 87a9594b..968922af 100644
--- a/workflows/sra.nf
+++ b/workflows/sra.nf
@@ -16,7 +16,7 @@ process prefetch_sra{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".log") >0)              "LOGS/$CONDITION/FETCH/Prefetch_SRA.log"
+        if (filename.indexOf(".log") >0)              "LOGS/$CONDITION/FETCH/sra/Prefetch_SRA.log"
         else null
     }
 
@@ -44,7 +44,7 @@ process download_sra{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".fastq.gz") > 0)                "FASTQ/$CONDITION/${file(filename).getSimpleName()}.fastq.gz"
-        else if (filename.indexOf(".log") >0)              "LOGS/$CONDITION/FETCH/SRA.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/$CONDITION/FETCH/sra/SRA.log"
         else null
     }
 
diff --git a/workflows/sra.smk b/workflows/sra.smk
index b215166b..14f811b7 100644
--- a/workflows/sra.smk
+++ b/workflows/sra.smk
@@ -7,7 +7,7 @@ if paired == 'paired':
         
     rule fetch_from_sra:
         output: prefetch = temp("TMP/{srafile}.sra")
-        log:    "LOGS/FETCH/prefetch_{srafile}.log"
+        log:    "LOGS/{srafile}/FETCH/sra/prefetch.log"
         conda:  ""+FETCHENV+".yaml"
         container: "oras://jfallmann/monsda:"+FETCHENV+""
         params: ids = lambda wildcards: os.path.splitext(os.path.basename(wildcards.srafile))[0],
@@ -17,7 +17,7 @@ if paired == 'paired':
     rule get_from_sra:
         input: prefetch = rules.fetch_from_sra.output.prefetch
         output: fq = expand("FASTQ/{{srafile}}_{read}.fastq.gz", read=['R1','R2'])
-        log:    "LOGS/FETCH/{srafile}.log"
+        log:    "LOGS/{srafile}/FETCH/sra/run.log"
         conda:  ""+FETCHENV+".yaml"
         container: "oras://jfallmann/monsda:"+FETCHENV+""
         threads: min(MAXTHREAD, 6)
@@ -36,7 +36,7 @@ else:
 
     rule fetch_from_sra:
         output: prefetch = temp("TMP/{srafile}.sra")
-        log:    "LOGS/FETCH/prefetch_{srafile}.log"
+        log:    "LOGS/{srafile}/FETCH/sra/prefetch.log"
         conda:  ""+FETCHENV+".yaml"
         container: "oras://jfallmann/monsda:"+FETCHENV+""
         params: ids = lambda wildcards: os.path.splitext(os.path.basename(wildcards.srafile))[0],
@@ -46,7 +46,7 @@ else:
     rule get_from_sra:
         input: prefetch = rules.fetch_from_sra.output.prefetch
         output: fq = "FASTQ/{srafile}.fastq.gz"
-        log:    "LOGS/FETCH/{srafile}.log"
+        log:    "LOGS/{srafile}/FETCH/sra/run.log"
         conda:  ""+FETCHENV+".yaml"
         container: "oras://jfallmann/monsda:"+FETCHENV+""
         threads: min(MAXTHREAD, 6)
diff --git a/workflows/star.nf b/workflows/star.nf
index 1a96cd0b..1ce6d533 100644
--- a/workflows/star.nf
+++ b/workflows/star.nf
@@ -37,7 +37,7 @@ process star_idx{
 
     publishDir "${workflow.workDir}/../" , mode: 'copyNoFollow', overwrite: true,
     saveAs: {filename ->
-        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/star_index.log"
+        if (filename.indexOf("Log.out") > 0)             "LOGS/${COMBO}/${CONDITION}/MAPPING/star/index.log"
         else if (filename.indexOf(".idx") > 0)           "$MAPIDX"
         else                                             "$MAPUIDX"
     }
@@ -72,8 +72,8 @@ process star_mapping{
     saveAs: {filename ->
         if (filename.indexOf("_unmapped") > 0)       "UNMAPPED/${COMBO}/${CONDITION}/"+"${file(filename).getName()}"
         //else if (filename.indexOf(".sam.gz") >0)     "MAPPED/${COMBO}/${CONDITION}/"+"${filename.replaceAll(/\Q.Aligned.out.sam.gz\E/,"")}_mapped.sam.gz"
-        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
-        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star_"+"${file(filename).getName()}"
+        else if (filename.indexOf(".log") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star/"+"${file(filename).getName()}"
+        else if (filename.indexOf(".out") >0)        "LOGS/${COMBO}/${CONDITION}/MAPPING/star/"+"${file(filename).getName()}"
         else if (filename.indexOf(".tab") >0)        "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
         else                                         "MAPPED/${COMBO}/${CONDITION}/"+"${filename}"
     }
diff --git a/workflows/star.smk b/workflows/star.smk
index 2ddc513f..f94e75dd 100644
--- a/workflows/star.smk
+++ b/workflows/star.smk
@@ -12,7 +12,7 @@ rule generate_index:
             idxfile = expand("{refd}/INDICES/{mape}_{unikey}/{pref}.idx", refd=REFDIR, mape=MAPPERENV, unikey=unik, pref=PREFIX),
             tmpfa = temp(expand("TMP/{mape}_{unikey}/ref.fa", mape=MAPPERENV, unikey=unik)),
             tmpref = temp(expand("TMP/{mape}_{unikey}/ref.anno", mape=MAPPERENV, unikey=unik))
-    log:    expand("LOGS/{sets}/{mape}.idx.log", sets=SETS, mape=MAPPERENV)
+    log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV+".yaml"
     container: "oras://jfallmann/monsda:"+MAPPERENV+""
     threads: MAXTHREAD
@@ -34,10 +34,10 @@ if paired == 'paired':
         output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                log = "LOGS/{combo}/{file}/Log.out",
-                log_final = "LOGS/{combo}/{file}/Log.final.out",
+                log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
-        log:    "LOGS/{combo}/{file}/mapping.log"
+        log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
         container: "oras://jfallmann/monsda:"+MAPPERENV+""
         threads: MAXTHREAD
@@ -57,10 +57,10 @@ else:
                     ref = REFERENCE
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
@@ -80,10 +80,10 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
-                    log = "LOGS/{combo}/{file}/Log.out",
-                    log_final = "LOGS/{combo}/{file}/Log.final.out",
+                    log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
-            log:    "LOGS/{combo}/{file}/mapping.log"
+            log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
             container: "oras://jfallmann/monsda:"+MAPPERENV+""
             threads: MAXTHREAD
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index 602c7f3d..0fb1af3c 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -19,7 +19,7 @@ process starfusion{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
         else      "FUSIONS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
     }
 
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index 4dfc03b1..865d889a 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -27,7 +27,7 @@ rule generate_ctat_lib:
     output: lib = directory(CTATLIB),
             tmpfa = temp(expand("TMP/{fenv}/ctat_ref.fa", fenv=FENV)),
             tmpanno = temp(expand("TMP/{fenv}/ctat_ref.gtf", fenv=FENV))
-    log:    expand("LOGS/{sets}/{fenv}.ctat.log", sets=SETS, fenv=FENV)
+    log:    expand("LOGS/{sets}/FUSIONS/{fenv}/ctat.log", sets=SETS, fenv=FENV)
     conda:  ""+FENV+".yaml"
     container: "oras://jfallmann/monsda:"+FENV+""
     threads: MAXTHREAD
@@ -48,7 +48,7 @@ if not fastqmode:
         output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                 abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv",
                 normjunc = "FUSIONS/{combo}/{file}.Chimeric.norm.junction"
-        log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+        log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
         conda:  ""+FENV+".yaml"
         container: "oras://jfallmann/monsda:"+FENV+""
         threads: MAXTHREAD
@@ -63,7 +63,7 @@ else:
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
-            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
             conda:  ""+FENV+".yaml"
             container: "oras://jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
@@ -76,7 +76,7 @@ else:
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
-            log:    "LOGS/FUSIONS/{combo}/{file}_starfusion.log"
+            log:    "LOGS/{combo}/{file}/FUSIONS/starfusion/starfusion.log"
             conda:  ""+FENV+".yaml"
             container: "oras://jfallmann/monsda:"+FENV+""
             threads: MAXTHREAD
diff --git a/workflows/summary.nf b/workflows/summary.nf
index dcc61e20..8be0649c 100644
--- a/workflows/summary.nf
+++ b/workflows/summary.nf
@@ -8,7 +8,7 @@ process make_rmd{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename == 'SUMMARY.html')         "REPORTS/SUMMARY/SUMMARY.html"                               
-        else if (filename.indexOf("log") > 0)        "LOGS/REPORTS/SUMMARY/make_rmd.log"
+        else if (filename.indexOf("log") > 0)        "LOGS/SUMMARY/summary/make_rmd.log"
     }
 
     input:
diff --git a/workflows/summary.smk b/workflows/summary.smk
index c36c43b0..bd41b764 100644
--- a/workflows/summary.smk
+++ b/workflows/summary.smk
@@ -11,7 +11,7 @@ rule make_rmd:
     input:  os.path.join(outdir,'summary.Rmd')
     output: rules.themall.input.summary_all
             # rules.themall.input.summarys
-    log:    expand("LOGS/{outdir}/make_rmd.log", outdir=outdir)
+    log:    expand("LOGS/{outdir}/SUMMARY/summary/make_rmd.log", outdir=outdir)
     conda:  "summary.yaml"
     container: "oras://jfallmann/monsda:summary"
     params: outdir = outdir,
diff --git a/workflows/trimgalore.nf b/workflows/trimgalore.nf
index 38e31390..3f0b80ed 100644
--- a/workflows/trimgalore.nf
+++ b/workflows/trimgalore.nf
@@ -15,7 +15,7 @@ process trim{
     saveAs: {filename ->
         if (filename.indexOf("_trimmed.fastq.gz") > 0)     "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/_val_\d{1}|_trimmed|_dedup/,"")}_trimmed.fastq.gz"
         else if (filename.indexOf("report.txt") >0)        "TRIMMED_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName().replaceAll(/.fastq.gz/,"")}_trimming_report.txt"
-        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/${file(filename).getSimpleName()}.log"
+        else if (filename.indexOf(".log") >0)              "LOGS/${COMBO}/${CONDITION}/TRIMMING/trimgalore/${file(filename).getSimpleName()}.log"
         else null
     }
 
diff --git a/workflows/trimgalore.smk b/workflows/trimgalore.smk
index bb0f15d9..bd92836f 100644
--- a/workflows/trimgalore.smk
+++ b/workflows/trimgalore.smk
@@ -15,7 +15,7 @@ if paired == 'paired':
                 r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_R1_val_1.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R1_dedup_val_1.fq.gz",
                 o2 = "TRIMMED_FASTQ/{combo}/{file}_R2_val_2.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_R2_dedup_val_2.fq.gz"
-        log:   "LOGS/{combo}/{file}_trim.log"
+        log:   "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
@@ -38,7 +38,7 @@ else:
     rule trimgalore_trim:
         input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]) if not prededup else "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz"
         output: o1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fq.gz" if not prededup else "TRIMMED_FASTQ/{combo}/{file}_dedup_trimmed.fq.gz"
-        log:    "LOGS/{combo}/{file}_trim.log"
+        log:    "LOGS/{combo}/{file}/TRIMMING/trimgalore/trim.log"
         conda: ""+TRIMENV+".yaml"
         container: "oras://jfallmann/monsda:"+TRIMENV+""
         threads: min(int(MAXTHREAD/2),4) if min(int(MAXTHREAD/2),4) >= 1 else (4 if int(MAXTHREAD) >= 4 else 1)
diff --git a/workflows/ucsc.nf b/workflows/ucsc.nf
index 0bb71634..b9fb5a93 100644
--- a/workflows/ucsc.nf
+++ b/workflows/ucsc.nf
@@ -21,7 +21,7 @@ process BamToBed{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bed.gz") > 0)      "BED/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bam2bed.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/ucsc/${file(filename).getName()}_bam2bed.log"
     }
 
     input:
@@ -59,7 +59,7 @@ process BedToBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bedg.gz") > 0)      "TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscbedtobedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/ucsc/${file(filename).getName()}_ucscbedtobedgraph.log"
     }
 
     input:
@@ -97,7 +97,7 @@ process NormalizeBedg{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".norm.bedg.gz") > 0)      "TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_ucscnormalizebedgraph.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/ucsc/${file(filename).getName()}_ucscnormalizebedgraph.log"
     }
 
     input:
@@ -131,7 +131,7 @@ process BedgToTRACKS{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".bw") > 0)      "TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"                
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}_bedgtoucsc.log"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/ucsc/${file(filename).getName()}_bedgtoucsc.log"
     }
 
     input:
@@ -166,7 +166,7 @@ process GenerateTrack{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".txt") > 0)      "TRACKS/${file(filename).getName()}"
-        else if (filename == ".log")        "LOGS/TRACKS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else if (filename == ".log")        "LOGS/${SCOMBO}/${CONDITION}/TRACKS/ucsc/${file(filename).getName()}"
     }
 
     input:
diff --git a/workflows/ucsc.smk b/workflows/ucsc.smk
index 57585a4b..4d664160 100644
--- a/workflows/ucsc.smk
+++ b/workflows/ucsc.smk
@@ -17,7 +17,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/TRACKS/ucsc/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -28,7 +28,7 @@ if not all(checklist):
         rule BamToBed:
             input:  expand("MAPPED/{scombo}/{{file}}_mapped_{{type}}.bam", scombo=scombo)
             output: "BED/{scombo}/{file}_mapped_{type}.bed.gz"
-            log:    "LOGS/PEAKS/{scombo}/{file}bam2bed_{type}.log"
+            log:    "LOGS/{scombo}/{file}/TRACKS/ucsc/bam2bed_{type}.log"
             conda:  "bedtools.yaml"
             container: "oras://jfallmann/monsda:bedtools"
             threads: 1
@@ -51,7 +51,7 @@ if not all(checklist):
                 sizes = expand("{ref}.chrom.sizes", ref=REFERENCE.replace('.fa.gz', '').replace('.fa.bgz', '').removesuffix('.fa'))
         output: fw = "TRACKS/{combo}/{file}_mapped_{type}.fw.bedg.gz",
                 re = "TRACKS/{combo}/{file}_mapped_{type}.re.bedg.gz"
-        log:    "LOGS/TRACKS/{combo}/{file}_{type}_ucscbedtobedgraph.log"
+        log:    "LOGS/{combo}/{file}/TRACKS/ucsc/{type}_ucscbedtobedgraph.log"
         conda:  "bedtools.yaml"
         container: "oras://jfallmann/monsda:bedtools"
         threads: 1
@@ -64,7 +64,7 @@ rule NormalizeBedg:
             re = rules.BedToBedg.output.re
     output: fw = "TRACKS/{combo}/{file}_mapped_{type}.fw.norm.bedg.gz",
             re = "TRACKS/{combo}/{file}_mapped_{type}.re.norm.bedg.gz"
-    log:    "LOGS/TRACKS/{combo}/{file}_{type}_ucscnormalizebedgraph.log"
+    log:    "LOGS/{combo}/{file}/TRACKS/ucsc/{type}_ucscnormalizebedgraph.log"
     conda:  "perl.yaml"
     container: "oras://jfallmann/monsda:perl"
     threads: 1
@@ -80,7 +80,7 @@ rule BedgToTRACKS:
             re = "TRACKS/{combo}/{file}_mapped_{type}.re.bw",
             tfw = temp("TRACKS/{combo}/{file}_mapped_{type}.fw.tmp"),
             tre = temp("TRACKS/{combo}/{file}_mapped_{type}.re.tmp")
-    log:    "LOGS/TRACKS/{combo}/{file}_{type}_bedgtoucsc.log"
+    log:    "LOGS/{combo}/{file}/TRACKS/ucsc/{type}_bedgtoucsc.log"
     conda:  "ucsc.yaml"
     container: "oras://jfallmann/monsda:ucsc"
     threads: 1
@@ -92,7 +92,7 @@ rule GenerateTrack:
             re = rules.BedgToTRACKS.output.re
     output: "TRACKS/{combo}/{file}_mapped_{type}.fw.bw.trackdone",
             "TRACKS/{combo}/{file}_mapped_{type}.re.bw.trackdone"
-    log:    "LOGS/TRACKS/{combo}/{file}_track_{type}.log"
+    log:    "LOGS/{combo}/{file}/TRACKS/ucsc/track_{type}.log"
     conda:  "base.yaml"
     container: "oras://jfallmann/monsda:base"
     threads: MAXTHREAD
diff --git a/workflows/umicollapse.nf b/workflows/umicollapse.nf
index 2968c5b2..d109297f 100644
--- a/workflows/umicollapse.nf
+++ b/workflows/umicollapse.nf
@@ -17,7 +17,7 @@ process whitelist{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_whitelist") > 0)         "DEDUP_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}_whitelist"
-        else if (filename.indexOf("log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/dedup_whitelist.log"
+        else if (filename.indexOf("log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/umicollapse/whitelist.log"
         else null
     }
 
@@ -61,7 +61,7 @@ process extract_fq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_dedup.fastq.gz") > 0)      "DEDUP_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.fastq.gz"
-        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/dedup_extract.log"
+        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/umicollapse/extract.log"
         else null
     }
 
diff --git a/workflows/umicollapse.smk b/workflows/umicollapse.smk
index e7a83c9e..6ea555d1 100644
--- a/workflows/umicollapse.smk
+++ b/workflows/umicollapse.smk
@@ -15,7 +15,7 @@ if paired == 'paired':
                     r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: wl = "DEDUP_FASTQ/{combo}/{file}_whitelist",
                     td = temp(directory("TMP/UMIWL/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_whitelist.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_whitelist.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -33,7 +33,7 @@ if paired == 'paired':
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
                     o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -50,7 +50,7 @@ if paired == 'paired':
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
                     o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -67,7 +67,7 @@ else:
             input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: wl = "DEDUP_FASTQ/{combo}/{file}_whitelist",
                     td = temp(directory("TMP/UMIWL/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_whitelist.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_whitelist.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -83,7 +83,7 @@ else:
                     wl = rules.whitelist.output.wl
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -99,7 +99,7 @@ else:
             input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umicollapse/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -116,7 +116,7 @@ if paired == 'paired':
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/umicollapse/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
@@ -133,7 +133,7 @@ else:
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/umicollapse/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
diff --git a/workflows/umicollapse_dedup.nf b/workflows/umicollapse_dedup.nf
index 8a77bc60..fe84cdfa 100644
--- a/workflows/umicollapse_dedup.nf
+++ b/workflows/umicollapse_dedup.nf
@@ -14,7 +14,7 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0) "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/umicollapse/${file(filename).getName()}"
         else null
     }
 
diff --git a/workflows/umitools.nf b/workflows/umitools.nf
index 83210648..45133be5 100644
--- a/workflows/umitools.nf
+++ b/workflows/umitools.nf
@@ -14,7 +14,7 @@ process whitelist{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_whitelist") > 0)         "DEDUP_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}_whitelist"
-        else if (filename.indexOf("log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/dedup_whitelist.log"
+        else if (filename.indexOf("log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/umitools/whitelist.log"
         else null
     }
 
@@ -58,7 +58,7 @@ process extract_fq{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf("_dedup.fastq.gz") > 0)      "DEDUP_FASTQ/${COMBO}/${CONDITION}/${file(filename).getSimpleName()}.fastq.gz"
-        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/dedup_extract.log"
+        else if (filename.indexOf("log") > 0)             "LOGS/${COMBO}/${CONDITION}/DEDUP/umitools/extract.log"
         else null
     }
 
diff --git a/workflows/umitools.smk b/workflows/umitools.smk
index 041bef2c..6a58376a 100644
--- a/workflows/umitools.smk
+++ b/workflows/umitools.smk
@@ -12,7 +12,7 @@ if paired == 'paired':
                     r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: wl = "DEDUP_FASTQ/{combo}/{file}_whitelist",
                     td = temp(directory("TMP/UMIWL/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_whitelist.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_whitelist.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -27,7 +27,7 @@ if paired == 'paired':
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
                     o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -41,7 +41,7 @@ if paired == 'paired':
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
                     o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -55,7 +55,7 @@ else:
             input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: wl = "DEDUP_FASTQ/{combo}/{file}_whitelist",
                     td = temp(directory("TMP/UMIWL/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_whitelist.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_whitelist.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -68,7 +68,7 @@ else:
                     wl = rules.whitelist.output.wl
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -81,7 +81,7 @@ else:
             input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
             output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
                     td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}_dedup_extract.log"
+            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
             conda: ""+DEDUPENV+".yaml"
             container: "oras://jfallmann/monsda:"+DEDUPENV+""
             threads: 1
@@ -95,7 +95,7 @@ if paired == 'paired':
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/umitools/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
@@ -109,7 +109,7 @@ else:
         output: bam = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam", category="DEDUP"),
                 bai = report("MAPPED/{combo}/{file}_mapped_{type}_dedup.bam.bai", category="DEDUP"),
                 td = temp(directory("TMP/UMIDD/{combo}/{file}_{type}"))
-        log:    "LOGS/{combo}/{file}_{type}/dedupbam.log"
+        log:    "LOGS/{combo}/{file}/DEDUP/umitools/dedupbam_{type}.log"
         conda:  ""+DEDUPENV+".yaml"
         container: "oras://jfallmann/monsda:"+DEDUPENV+""
         threads: 1
diff --git a/workflows/umitools_dedup.nf b/workflows/umitools_dedup.nf
index 834f2fe9..242cafdf 100644
--- a/workflows/umitools_dedup.nf
+++ b/workflows/umitools_dedup.nf
@@ -14,7 +14,7 @@ process dedup_bam{
     saveAs: {filename ->
         if (filename.endsWith("_dedup.bam"))          "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
         else if (filename.indexOf("_dedup.bam.bai") > 0) "MAPPED/${COMBO}/${CONDITION}/${file(filename).getName()}"
-        else if (filename.indexOf("dedup.log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/${file(filename).getName()}"
+        else if (filename.indexOf("dedup.log") > 0)           "LOGS/${COMBO}/${CONDITION}/DEDUP/umitools/${file(filename).getName()}"
         else null
     }
 

From b001846e58cb5f87cc34add25d71dc9344b50345 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 09:33:54 +0200
Subject: [PATCH 37/80] multiqc modules are case sensitive, fixed map from env
 to module

---
 MONSDA/Versions.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/MONSDA/Versions.py b/MONSDA/Versions.py
index 3c1b9ab0..eeacb33f 100644
--- a/MONSDA/Versions.py
+++ b/MONSDA/Versions.py
@@ -25,16 +25,17 @@
 )
 
 # Mapping of tool/package name to the corresponding MultiQC module name,
-# None means MultiQC has no module for this tool
+# names have to match the modules of MultiQC exactly, including case,
+# tools without a MultiQC module are not listed
 MULTIQC_MODULES = {
     "bbmap": "bbmap",
-    "bbduk": "bbmap",
+    "bbduk": "bbduk",
     "bismark": "bismark",
     "bowtie2": "bowtie2",
     "cutadapt": "cutadapt",
     "fastp": "fastp",
     "fastqc": "fastqc",
-    "featurecounts": "featurecounts",
+    "featurecounts": "featureCounts",
     "hisat2": "hisat2",
     "htseq": "htseq",
     "kallisto": "kallisto",
@@ -45,11 +46,10 @@
     "salmon": "salmon",
     "samtools": "samtools",
     "star": "star",
-    "subread": "featurecounts",
+    "subread": "featureCounts",
     "trimgalore": "cutadapt",
     "trim-galore": "cutadapt",
     "trimmomatic": "trimmomatic",
-    "umicollapse": "umicollapse",
     "umitools": "umitools",
     "umi_tools": "umitools",
 }
@@ -272,6 +272,13 @@ def collect_versions(config, steps, envdir):
                 + str(yamlfile)
             )
             packages = {env: "unknown"}
+        # tools shipped by a differently named package, e.g. bbduk by bbmap,
+        # need their own MultiQC module to be reported
+        envmod = multiqc_module(env)
+        if envmod and envmod not in [multiqc_module(pkg) for pkg in packages]:
+            packages[env] = (
+                list(packages.values())[0] if len(packages) == 1 else "unknown"
+            )
         for pkg, version in packages.items():
             tools.setdefault(pkg, [version, set()])
             tools[pkg][0] = version

From 1c40b58234036e6b4283d6ac62ff3f608b673230 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 10:00:27 +0200
Subject: [PATCH 38/80] build script path upadte

---
 containers/apptainer/build_all_local.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/containers/apptainer/build_all_local.sh b/containers/apptainer/build_all_local.sh
index 31ec77fb..b0689af2 100755
--- a/containers/apptainer/build_all_local.sh
+++ b/containers/apptainer/build_all_local.sh
@@ -2,7 +2,7 @@
 set -uo pipefail
 
 repo=${HOME}/Gits/Monsda
-out=${HOME}/Work/Container/MONSDA
+out=${HOME}/Work22/Container/MONSDA
 script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
 revision=$(cd "$repo" && git rev-parse HEAD)

From 467004a0e6257628699822cb9e0ff0a19848bee3 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 10:01:53 +0200
Subject: [PATCH 39/80] typo

---
 containers/apptainer/build_all_local.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/containers/apptainer/build_all_local.sh b/containers/apptainer/build_all_local.sh
index b0689af2..6843cd53 100755
--- a/containers/apptainer/build_all_local.sh
+++ b/containers/apptainer/build_all_local.sh
@@ -2,7 +2,7 @@
 set -uo pipefail
 
 repo=${HOME}/Gits/Monsda
-out=${HOME}/Work22/Container/MONSDA
+out=${HOME}/Work2/Container/MONSDA
 script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
 revision=$(cd "$repo" && git rev-parse HEAD)

From 75dc1dbafb8b13acf5fb007c6ade02ce57537427 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 10:04:33 +0200
Subject: [PATCH 40/80] set path via cli

---
 containers/apptainer/build_all_local.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/containers/apptainer/build_all_local.sh b/containers/apptainer/build_all_local.sh
index 6843cd53..6375390f 100755
--- a/containers/apptainer/build_all_local.sh
+++ b/containers/apptainer/build_all_local.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 set -uo pipefail
 
-repo=${HOME}/Gits/Monsda
-out=${HOME}/Work2/Container/MONSDA
+repo=${1:-${HOME}/Gits/Monsda}
+out=${2:-${HOME}/Work2/Container/MONSDA}
 script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 version=$(cd "$repo" && python scripts/container_matrix.py --version | cut -d= -f2)
 revision=$(cd "$repo" && git rev-parse HEAD)

From bc0c9499eb2cbf07d343fbfc5c3de7d2015e58f4 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 11:12:39 +0200
Subject: [PATCH 41/80] multiqc module and parameter fixes for all combinations
 of qc tools

---
 MONSDA/Versions.py                            | 25 ++++++++++++++++---
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 17 +++++++------
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf | 17 +++++++------
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 17 +++++++------
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 17 +++++++------
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf | 17 +++++++------
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 17 +++++++------
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 17 +++++++------
 ...fastqc-trimgalore-picard-rustar_subflow.nf | 17 +++++++------
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 17 +++++++------
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk | 12 ++++-----
 ...st_fastqc-bbduk-picard-rustar_subsnake.smk | 12 ++++-----
 ...Test_fastqc-bbduk-picard-star_subsnake.smk | 12 ++++-----
 ...st_fastqc-cutadapt-picard-bwa_subsnake.smk | 12 ++++-----
 ...fastqc-cutadapt-picard-rustar_subsnake.smk | 12 ++++-----
 ...t_fastqc-cutadapt-picard-star_subsnake.smk | 12 ++++-----
 ..._fastqc-trimgalore-picard-bwa_subsnake.smk | 12 ++++-----
 ...stqc-trimgalore-picard-rustar_subsnake.smk | 12 ++++-----
 ...fastqc-trimgalore-picard-star_subsnake.smk | 12 ++++-----
 workflows/multiqc.nf                          | 14 +++++------
 workflows/multiqc.smk                         | 12 ++++-----
 workflows/multiqc_rustqc.nf                   | 14 +++++------
 workflows/multiqc_rustqc.smk                  |  4 +--
 workflows/premultiqc.nf                       | 14 +++++------
 workflows/premultiqc.smk                      |  4 +--
 25 files changed, 196 insertions(+), 152 deletions(-)

diff --git a/MONSDA/Versions.py b/MONSDA/Versions.py
index eeacb33f..906ad039 100644
--- a/MONSDA/Versions.py
+++ b/MONSDA/Versions.py
@@ -24,9 +24,10 @@
     ]
 )
 
-# Mapping of tool/package name to the corresponding MultiQC module name,
+# Mapping of tool/package name to the corresponding MultiQC module name(s),
 # names have to match the modules of MultiQC exactly, including case,
-# tools without a MultiQC module are not listed
+# tools without a MultiQC module are not listed, tools reporting the output of
+# several other tools, like rustqc, map to all modules they produce output for
 MULTIQC_MODULES = {
     "bbmap": "bbmap",
     "bbduk": "bbduk",
@@ -43,6 +44,16 @@
     "macs3": "macs2",
     "picard": "picard",
     "qualimap": "qualimap",
+    "rastqc": "fastqc",
+    "rseqc": "rseqc",
+    "rustqc": (
+        "custom_content",
+        "featureCounts",
+        "preseq",
+        "qualimap",
+        "rseqc",
+        "samtools",
+    ),
     "salmon": "salmon",
     "samtools": "samtools",
     "star": "star",
@@ -56,7 +67,7 @@
 
 
 def multiqc_module(tool):
-    """Return the MultiQC module name for a tool or None if there is none
+    """Return the MultiQC module(s) for a tool or None if there is none
 
     Parameters
     ----------
@@ -66,8 +77,14 @@ def multiqc_module(tool):
     Returns
     -------
     str or None
+        module name, comma separated if the tool reports for several modules
     """
-    return MULTIQC_MODULES.get(str(tool).lower().replace("_", "").replace("-", "")) or MULTIQC_MODULES.get(str(tool).lower())
+    module = MULTIQC_MODULES.get(
+        str(tool).lower().replace("_", "").replace("-", "")
+    ) or MULTIQC_MODULES.get(str(tool).lower())
+    if isinstance(module, tuple):
+        return ",".join(module)
+    return module
 
 
 def envs_from_config(config, steps):
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index 968aad26..ad58061b 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
@@ -49,6 +49,9 @@ params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
 params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -488,8 +491,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -527,11 +530,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index 1d4806c1..0b3cb040 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -519,8 +522,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -558,11 +561,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 19c5c75f..7b80f139 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('bbduk_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -519,8 +522,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -558,11 +561,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index 7032e3e9..9d2b099a 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
@@ -49,6 +49,9 @@ params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
 params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -488,8 +491,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -527,11 +530,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index dd066640..66244bfb 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -519,8 +522,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -558,11 +561,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index 7161a718..f3db910f 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('cutadapt_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -519,8 +522,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -558,11 +561,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index efe016fa..6dea161f 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
@@ -49,6 +49,9 @@ params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('bwa_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('bwa_params_MAP') ?: ''
 params.gIDXBIN = params.gMAPBIN.split('_')[0]
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -483,8 +486,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -522,11 +525,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index 50a71593..d53030ca 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('rustar_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('rustar_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -514,8 +517,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -553,11 +556,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index d4b671df..b9a8cfc9 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -27,9 +27,9 @@ def samples_ch(){
     def samples_ch = Channel.fromPath(params.gRSAMPLES)
     return samples_ch
 }
-params.gQCENV = { def QCENV = get_always('PREQCENV'); QCENV = get_always('PREQCENV'); return QCENV }()
-params.gQCBIN = { def QCBIN = get_always('PREQCBIN'); QCBIN = get_always('PREQCBIN'); return QCBIN }()
-params.gQCPARAMS = { def QCPARAMS = get_always('fastqc_params_QC') ?: ''; QCPARAMS = get_always('fastqc_params_MULTI') ?: ''; return QCPARAMS }()
+params.gQCENV = get_always('PREQCENV')
+params.gQCBIN = get_always('PREQCBIN')
+params.gQCPARAMS = get_always('fastqc_params_QC') ?: ''
 params.gTRIMENV = get_always('TRIMMINGENV')
 params.gTRIMBIN = get_always('TRIMMINGBIN')
 params.gTRIMPARAMS = get_always('trimgalore_params_TRIM') ?: ''
@@ -48,6 +48,9 @@ params.gMAPANNO = get_always('MAPPINGANNO')
 params.gMAPPREFIX = get_always('MAPPINGPREFIX')
 params.gIDXPARAMS = get_always('star_params_INDEX') ?: ''
 params.gMAPPARAMS = get_always('star_params_MAP') ?: ''
+params.gMQCENV = get_always('PREQCENV')
+params.gMQCBIN = get_always('PREQCBIN')
+params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -514,8 +517,8 @@ workflow POSTMAPPING{
 
 
 process mqc{
-    conda "<REPO>/envs/${params.gQCENV}"+".yaml"
-    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gQCENV}"+"-VERSION"
+    conda "<REPO>/envs/${params.gMQCENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gMQCENV}"+"-VERSION"
     cpus params.gTHREADS
 	cache 'lenient'
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -553,11 +556,11 @@ process mqc{
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index 05f825f9..93e3b1ec 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -722,7 +722,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -743,7 +743,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -766,7 +766,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -787,7 +787,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -806,7 +806,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -824,7 +824,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
index 9d6e2fb7..4453be8d 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -637,7 +637,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -658,7 +658,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -681,7 +681,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -702,7 +702,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -721,7 +721,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -739,7 +739,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index f7fbcf26..be32e569 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -638,7 +638,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -659,7 +659,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -682,7 +682,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -703,7 +703,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -722,7 +722,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -740,7 +740,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index dde91676..b47c7f5c 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -722,7 +722,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -743,7 +743,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -766,7 +766,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -787,7 +787,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -806,7 +806,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -824,7 +824,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
index 3b1f67b5..a77dfece 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -637,7 +637,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -658,7 +658,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -681,7 +681,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -702,7 +702,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -721,7 +721,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -739,7 +739,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index a7dfcc3e..3ef1dd10 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -638,7 +638,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -659,7 +659,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -682,7 +682,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -703,7 +703,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -722,7 +722,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -740,7 +740,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index cdccc5b4..04767a42 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -729,7 +729,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -750,7 +750,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -773,7 +773,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -794,7 +794,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -813,7 +813,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -831,7 +831,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
index f83f9432..9fe5e72e 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -644,7 +644,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -665,7 +665,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -688,7 +688,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -709,7 +709,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -728,7 +728,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -746,7 +746,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 174dcaa3..8a363eed 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -645,7 +645,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -666,7 +666,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -689,7 +689,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -710,7 +710,7 @@ if rundedup:
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -729,7 +729,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -747,7 +747,7 @@ else:
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/workflows/multiqc.nf b/workflows/multiqc.nf
index 601ca4c6..8f4940d0 100644
--- a/workflows/multiqc.nf
+++ b/workflows/multiqc.nf
@@ -1,10 +1,10 @@
-QCENV=get_always('PREQCENV')
-QCBIN=get_always('PREQCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+MQCENV=get_always('PREQCENV')
+MQCBIN=get_always('PREQCBIN')
+MQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 
 process mqc{
-    conda "$QCENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$QCENV"
+    conda "$MQCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MQCENV"
     cpus THREADS
 	cache 'lenient'
     //validExitStatus 0,1
@@ -51,11 +51,11 @@ process mqc{
 
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 
diff --git a/workflows/multiqc.smk b/workflows/multiqc.smk
index eccae6ec..abe2a823 100644
--- a/workflows/multiqc.smk
+++ b/workflows/multiqc.smk
@@ -21,7 +21,7 @@ if rundedup:
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -42,7 +42,7 @@ if rundedup:
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         if prededup:
@@ -66,7 +66,7 @@ if rundedup:
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -87,7 +87,7 @@ if rundedup:
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     if paired == 'paired':
@@ -107,7 +107,7 @@ else:
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         rule multiqc:
@@ -126,4 +126,4 @@ else:
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/multiqc_rustqc.nf b/workflows/multiqc_rustqc.nf
index 047e794d..914ca21b 100644
--- a/workflows/multiqc_rustqc.nf
+++ b/workflows/multiqc_rustqc.nf
@@ -1,10 +1,10 @@
-QCENV=get_always('POSTQCENV')
-QCBIN=get_always('POSTQCBIN')
-QCPARAMS = get_always('rustqc_params_MULTI') ?: ''
+MQCENV=get_always('POSTQCENV')
+MQCBIN=get_always('POSTQCBIN')
+MQCPARAMS = get_always('rustqc_params_MULTI') ?: ''
 
 process mqc{
-    conda "$QCENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$QCENV"
+    conda "$MQCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MQCENV"
     cpus THREADS
 	cache 'lenient'
     //validExitStatus 0,1
@@ -51,11 +51,11 @@ process mqc{
 
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
     """
 }
 
diff --git a/workflows/multiqc_rustqc.smk b/workflows/multiqc_rustqc.smk
index 93ab506f..b1b108eb 100644
--- a/workflows/multiqc_rustqc.smk
+++ b/workflows/multiqc_rustqc.smk
@@ -13,7 +13,7 @@ if paired == 'paired':
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
@@ -30,4 +30,4 @@ else:
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/premultiqc.nf b/workflows/premultiqc.nf
index 9a878187..1190efe9 100644
--- a/workflows/premultiqc.nf
+++ b/workflows/premultiqc.nf
@@ -1,7 +1,7 @@
 
-QCENV=get_always('QCENV')
-QCBIN=get_always('QCBIN')
-QCPARAMS = get_always('fastqc_params_MULTI') ?: ''
+MQCENV=get_always('MQCENV')
+MQCBIN=get_always('MQCBIN')
+MQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 
 process collect_multi{
     input:
@@ -18,8 +18,8 @@ process collect_multi{
 
 
 process premultiqc{
-    conda "$QCENV"+".yaml"
-    container "oras://jfallmann/monsda:"+"$QCENV"
+    conda "$MQCENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$MQCENV"
     cpus THREADS
 	cache 'lenient'
     //validExitStatus 0,1
@@ -52,11 +52,11 @@ process premultiqc{
 
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
-        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f \$MODS -k json -z -s -o "\$OUT" "\$SCAN"
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN"
     """
 }
 
diff --git a/workflows/premultiqc.smk b/workflows/premultiqc.smk
index 8225b9ec..979a066d 100644
--- a/workflows/premultiqc.smk
+++ b/workflows/premultiqc.smk
@@ -12,7 +12,7 @@ if paired == 'paired':
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
@@ -25,4 +25,4 @@ else:
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"

From 625441adb0ce95bb6a5f51529c8d89ac4e2f6acf Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 12:11:55 +0200
Subject: [PATCH 42/80] cleanup of multiqc params and output

---
 .../config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf       | 1 +
 .../config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf    | 1 +
 .../config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf      | 1 +
 .../config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf    | 1 +
 .../config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf | 1 +
 .../config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf   | 1 +
 .../config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf  | 1 +
 .../nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf           | 1 +
 .../config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf | 1 +
 workflows/multiqc.nf                                             | 1 +
 workflows/multiqc_rustqc.nf                                      | 1 +
 11 files changed, 11 insertions(+)

diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index ad58061b..32598f9a 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -506,6 +506,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index 0b3cb040..5591485c 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -537,6 +537,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 7b80f139..f9b9be97 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -537,6 +537,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index 9d2b099a..c4567b5b 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -506,6 +506,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index 66244bfb..9e1db4d8 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -537,6 +537,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index f3db910f..3159d209 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -537,6 +537,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index 6dea161f..6f8e94a7 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -501,6 +501,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index d53030ca..75eb9055 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -532,6 +532,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index b9a8cfc9..f5e7ac76 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -532,6 +532,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
     script:
     """
     touch $others
diff --git a/workflows/multiqc.nf b/workflows/multiqc.nf
index 8f4940d0..ab31357d 100644
--- a/workflows/multiqc.nf
+++ b/workflows/multiqc.nf
@@ -23,6 +23,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
 
     script:
     """
diff --git a/workflows/multiqc_rustqc.nf b/workflows/multiqc_rustqc.nf
index 914ca21b..89a6328b 100644
--- a/workflows/multiqc_rustqc.nf
+++ b/workflows/multiqc_rustqc.nf
@@ -23,6 +23,7 @@ process mqc{
     output:
     path "*.zip", emit: mqc
     path "*.html", emit: html
+    path "versions.txt", emit: versions, optional: true
 
     script:
     """

From fb8c6978a31ca887677cdce12a4c45f62e79024f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 19 Aug 2026 13:10:46 +0200
Subject: [PATCH 43/80] commiting agents.md

---
 AGENTS.md | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 AGENTS.md

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..d6d0b3cf
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,87 @@
+# Notes for AI agents
+
+## Keep the user updated
+
+Report progress **while** working, not only at the end. Before/while running a
+step, say what is being done and why, and show the relevant command output or
+diff. A silent stretch of work followed by one large summary makes the change
+impossible to judge and is not acceptable.
+
+State clearly what was actually verified and what was not.
+
+## Test environment
+
+`snakemake` and `nextflow` live in the `monsda` conda env, they are *not* on the
+default PATH:
+
+    export PATH=/home/fall/anaconda3/envs/monsda/bin:$PATH
+
+Confirmed there: snakemake 9.20.0, nextflow 26.04.0.12031. `multiqc` is **not**
+installed in that env, MultiQC behaviour cannot be verified locally.
+
+That env contains an installed copy of MONSDA in `site-packages`, *not* an
+editable install. It only picks up the working tree when the cwd is the repo, so
+runs from anywhere else need `PYTHONPATH=<repo>` or they silently test the
+installed release instead of the change.
+
+MONSDA aborts early if `nextflow` is missing, so `--nextflow` runs need that
+PATH.
+
+### Gotchas when running MONSDA from a checkout
+
+- `envpath`/`workflowpath` resolve to `<repo>/MONSDA/MONSDA/{envs,workflows}`,
+  which does not exist in a checkout. Create the symlinks before running and
+  remove them afterwards, they must not be committed:
+
+      mkdir -p MONSDA/MONSDA
+      ln -sfn ../../workflows MONSDA/MONSDA/workflows
+      ln -sfn ../../envs MONSDA/MONSDA/envs
+      ln -sfn ../../scripts MONSDA/MONSDA/scripts
+
+- `VERSION` in the config has to match the installed version exactly, otherwise
+  MONSDA refuses to run. Get it from `MONSDA.__version__` of the interpreter
+  used for the run, it differs between envs.
+
+- Generating without executing: run from the target directory with
+  `python -m MONSDA.RunMONSDA -c <config> -d <dir> -j 2 --save`. The declared
+  console script is `monsda`, not `MONSDA`, and it is not on PATH in the
+  `monsda` env, so use the module form and set `PYTHONPATH=<repo>` if the
+  interpreter does not already import MONSDA from the tree. Then
+  dry run every generated workflow via the calls in `JOBS/MONSDA.commands`
+  (`snakemake ... -n`). Note that `tests/data` ships no BAMs, so most sub
+  workflows fail with `MissingInputException` even on an unmodified tree,
+  compare the failure set against a pristine worktree instead of expecting zero
+  failures.
+
+- Workflow templates are snapshot tested. On intended changes regenerate with
+  `UPDATE_GOLDEN=1 python -m pytest` in `tests/` and check the golden diff only
+  contains the intended lines.
+
+- `${HOME}/MONSDA` is a symlink to this repo, the same tree under a second path.
+  Editor diagnostics may report paths there, they refer to these files.
+
+## Test data and configs
+
+`${HOME}/Work2/Tests/MONSDATest` is the user's test directory. It holds real
+input data (`FASTQ/{Ecoli,SIMPLE,FGUMI}`, `GENOMES/Ecoli` incl. prebuilt
+indices, 122 BAMs in `MAPPED/`), their own configs at the top level and outputs
+of earlier runs. Use it instead of `tests/data`, which ships no BAMs. It is not
+a git repo, so nothing there is protected by version control.
+
+Put configs written for a test into `TESTCONFIGS/` so they can be reused:
+
+- `config_multiqc_fastqc.json`, `config_multiqc_rustqc.json`: QC, TRIMMING,
+  DEDUP, MAPPING on `Ecoli/KO` with a `MULTI` option set. The rustqc one selects
+  the `multiqc_rustqc` template, the fastqc one `multiqc`.
+- `monsda_gen.sh <config> <outdir> [--nextflow]`: generates only (`--save`).
+  Creates the `MONSDA/MONSDA` symlinks, stamps `VERSION` with the tree's
+  `MONSDA.__version__` and links `FASTQ`/`GENOMES` into a sandbox `outdir`, so
+  the outputs in the test root are not overwritten. MONSDA resolves input data
+  relative to its working directory, hence the links.
+- `mqc_script_test.sh <generated_subflow.nf> [combo] [condition] [params]`: runs
+  the generated nextflow `mqc` process with a fake `multiqc` that records its
+  argv, and checks the module list from `LOGS/versions.txt`, the scanned
+  directories and the published files. `nextflow lint` and `-preview` do not
+  render script bodies, so this is the only local check of that bash.
+
+Do not run tests in the test root itself, generate into a subdirectory.

From f4f228580599e2f92681a483618b6f4aed086b51 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 21 Aug 2026 16:04:57 +0200
Subject: [PATCH 44/80] troubleshoot section added to readme

---
 README.md | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9271ea91..1b896fb0 100644
--- a/README.md
+++ b/README.md
@@ -129,6 +129,39 @@ To also run the heavier pipeline smoke test from the helper script:
 RUN_INTEGRATION_TESTS=1 bash tests/cicd_test.sh
 ```
 
+## Troubleshooting
+
+### `gzip`/`zcat: No such file or directory` for a `.gz` reference when running in a container (apptainer/singularity)
+
+MONSDA links `.bgz` reference files (genome, GTF/GFF, decoy) into `GENOMES/`
+with a `.gz` sibling symlink, so tools that expect the `.gz` extension keep
+working (bgzip output is gzip compatible). This symlink chain typically looks
+like:
+
+```
+GENOMES/hg38p14_softmasked.fa.gz -> hg38p14_softmasked.fa.bgz -> /path/to/original/hg38p14_softmasked.fa.bgz
+```
+
+The final target is an absolute path outside the run/project directory,
+pointing at wherever the reference was originally located. When a rule runs
+inside `apptainer`/`singularity`, only the run/project directory (and any
+paths you explicitly bind) are visible inside the container. If the original
+reference lives elsewhere on the host, resolving the symlink chain inside the
+container fails with an error such as:
+
+```
+gzip: GENOMES/hg38p14_softmasked.fa.gz: No such file or directory
+```
+
+even though the file exists and is readable outside the container.
+
+**Fix:** bind-mount the directory that holds the original reference file(s)
+into the container, in addition to the run directory, e.g. via
+`--singularity-args`/`--use-apptainer` bind options passed to snakemake, or
+the equivalent nextflow container options, so the symlink target is reachable
+from inside the container. For example, if your reference lives under
+`/scratch/arctic/GENOMES/human`, add that path (or its parent) as an
+additional bind path for the container run.
 
 ## Contribute
 If you like this project, are missing features, want to contribute or
@@ -144,4 +177,3 @@ workflows directory. Do not forget to also extend the template.json
 and add some documentation.
 
 PRs always welcome.
-

From adbb443f98bcef6c7e4d33cc91f932eccb6209d7 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 24 Aug 2026 11:18:08 +0200
Subject: [PATCH 45/80] fixed multiqc input paths and tests for different run
 scenarios

---
 AGENTS.md                                     |  3 ++
 scripts/Analysis/build_count_table_simple.py  |  0
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 24 ++++++-------
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf | 24 ++++++-------
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 24 ++++++-------
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 24 ++++++-------
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf | 24 ++++++-------
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 24 ++++++-------
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 24 ++++++-------
 ...fastqc-trimgalore-picard-rustar_subflow.nf | 24 ++++++-------
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 24 ++++++-------
 .../Test_fastqc-bbduk-picard-bwa_subsnake.smk | 36 +++++++------------
 ...st_fastqc-bbduk-picard-rustar_subsnake.smk | 36 +++++++------------
 ...Test_fastqc-bbduk-picard-star_subsnake.smk | 36 +++++++------------
 ...st_fastqc-cutadapt-picard-bwa_subsnake.smk | 36 +++++++------------
 ...fastqc-cutadapt-picard-rustar_subsnake.smk | 36 +++++++------------
 ...t_fastqc-cutadapt-picard-star_subsnake.smk | 36 +++++++------------
 ..._fastqc-trimgalore-picard-bwa_subsnake.smk | 36 +++++++------------
 ...stqc-trimgalore-picard-rustar_subsnake.smk | 36 +++++++------------
 ...fastqc-trimgalore-picard-star_subsnake.smk | 36 +++++++------------
 tests/test_Workflows.py                       | 24 +++++++++++++
 workflows/fastqc_dedup.smk                    | 12 +++----
 workflows/fastqc_dedup_trim.smk               | 12 +++----
 workflows/fastqc_raw.smk                      | 12 +++----
 workflows/fastqc_trim.smk                     | 12 +++----
 workflows/multiqc.nf                          | 24 ++++++-------
 workflows/multiqc.smk                         | 36 +++++++------------
 workflows/multiqc_rustqc.nf                   | 24 ++++++-------
 workflows/multiqc_rustqc.smk                  | 12 +++----
 workflows/premultiqc.nf                       | 12 +++----
 workflows/premultiqc.smk                      | 12 +++----
 workflows/rastqc_dedup.smk                    | 12 +++----
 workflows/rastqc_dedup_trim.smk               | 12 +++----
 workflows/rastqc_raw.smk                      | 12 +++----
 workflows/rastqc_trim.smk                     | 12 +++----
 workflows/rustqc.nf                           |  7 ++--
 36 files changed, 317 insertions(+), 473 deletions(-)
 mode change 100644 => 100755 scripts/Analysis/build_count_table_simple.py

diff --git a/AGENTS.md b/AGENTS.md
index d6d0b3cf..2876616e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -83,5 +83,8 @@ Put configs written for a test into `TESTCONFIGS/` so they can be reused:
   argv, and checks the module list from `LOGS/versions.txt`, the scanned
   directories and the published files. `nextflow lint` and `-preview` do not
   render script bodies, so this is the only local check of that bash.
+- `mqc_smk_test.py <generated_subsnake.smk> [combo] [condition]`: same idea for
+  the snakemake side, formats the generated `multiqc` rule's `shell:` string and
+  runs it against a fake `multiqc`.
 
 Do not run tests in the test root itself, generate into a subdirectory.
diff --git a/scripts/Analysis/build_count_table_simple.py b/scripts/Analysis/build_count_table_simple.py
old mode 100644
new mode 100755
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index 32598f9a..c1b60762 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -512,22 +512,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -535,7 +533,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index 5591485c..f12dbd57 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -543,22 +543,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -566,7 +564,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index f9b9be97..074b1263 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -543,22 +543,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -566,7 +564,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index c4567b5b..5bf6bd57 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -512,22 +512,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -535,7 +533,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index 9e1db4d8..7c8c0c9c 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -543,22 +543,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -566,7 +564,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index 3159d209..a88adb63 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -543,22 +543,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -566,7 +564,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index 6f8e94a7..24969530 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -507,22 +507,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -530,7 +528,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index 75eb9055..39e0c5f9 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -538,22 +538,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -561,7 +559,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index f5e7ac76..c5186453 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -538,22 +538,20 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${params.gCOMBO}/${params.gCONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${params.gCOMBO}"
     CONDITION_VAL="${params.gCONDITION}"
-    mkdir -p "\$COLLECT"
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -561,7 +559,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f ${params.gMQCPARAMS} \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 workflow MULTIQC{
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
index 93e3b1ec..7ed04df6 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-bwa_subsnake.smk
@@ -714,15 +714,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -735,15 +733,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -758,15 +754,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -779,15 +773,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -798,15 +790,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -816,15 +806,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
index 4453be8d..874f8515 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -629,15 +629,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -650,15 +648,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -673,15 +669,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -694,15 +688,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -713,15 +705,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -731,15 +721,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index be32e569..cda06755 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -630,15 +630,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -651,15 +649,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -674,15 +670,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -695,15 +689,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -714,15 +706,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -732,15 +722,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
index b47c7f5c..62494638 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-bwa_subsnake.smk
@@ -714,15 +714,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -735,15 +733,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -758,15 +754,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -779,15 +773,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -798,15 +790,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -816,15 +806,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
index a77dfece..171f1201 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -629,15 +629,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -650,15 +648,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -673,15 +669,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -694,15 +688,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -713,15 +705,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -731,15 +721,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index 3ef1dd10..0c2145d5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -630,15 +630,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -651,15 +649,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -674,15 +670,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -695,15 +689,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -714,15 +706,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -732,15 +722,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
index 04767a42..0c64e1c8 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-bwa_subsnake.smk
@@ -721,15 +721,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -742,15 +740,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -765,15 +761,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -786,15 +780,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -805,15 +797,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -823,15 +813,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
index 9fe5e72e..1c557b42 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -636,15 +636,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -657,15 +655,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -680,15 +676,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -701,15 +695,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -720,15 +712,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -738,15 +728,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 8a363eed..5cc08cc2 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -637,15 +637,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -658,15 +656,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         if prededup:
             rule multiqc:
@@ -681,15 +677,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -702,15 +696,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda: "<REPO>/envs/qc.yaml"
                 container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 else:
     if paired == 'paired':
         rule multiqc:
@@ -721,15 +713,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
     else:
         rule multiqc:
             input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -739,15 +729,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda: "<REPO>/envs/qc.yaml"
             container: "oras://ghcr.io/jfallmann/monsda:qc"+"-VERSION"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 
 ## Queue-agnostic fallback resources for all rules.
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index d1d56427..53a8b018 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -494,3 +494,27 @@ def test_container_builds_make_command_scripts_executable():
     assert definitions
     assert all(chmod_command in path.read_text() for path in definitions)
     assert chmod_command in (REPO / "docker" / "Dockerfile").read_text()
+
+
+def test_scripts_called_without_interpreter_are_executable():
+    called = re.compile(
+        r"(?<![\w./])(?:\{params\.bins\}|\$\{?BINS\}?|\$\{params\.gBINS\})"
+        r"/([\w/]+\.(?:py|pl|sh|R))"
+    )
+    interpreted = re.compile(r"(?:python3?|perl|Rscript|bash|sh)\s+$")
+    direct = set()
+    templates = sorted(
+        set((REPO / "workflows").glob("*.smk")) | set((REPO / "workflows").glob("*.nf"))
+    )
+    for template in templates:
+        text = template.read_text()
+        for match in called.finditer(text):
+            if not interpreted.search(text[: match.start()].rsplit("\n", 1)[-1]):
+                direct.add(match.group(1))
+    assert direct
+    not_executable = sorted(
+        name
+        for name in direct
+        if not os.access(REPO / "scripts" / name, os.X_OK)
+    )
+    assert not_executable == []
diff --git a/workflows/fastqc_dedup.smk b/workflows/fastqc_dedup.smk
index df9010e3..b0688108 100644
--- a/workflows/fastqc_dedup.smk
+++ b/workflows/fastqc_dedup.smk
@@ -36,15 +36,13 @@ if paired == 'paired':
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                 expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -70,12 +68,10 @@ else:
     rule multiqc:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
 		       expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/fastqc_dedup_trim.smk b/workflows/fastqc_dedup_trim.smk
index 3cb50285..ce8def80 100644
--- a/workflows/fastqc_dedup_trim.smk
+++ b/workflows/fastqc_dedup_trim.smk
@@ -47,15 +47,13 @@ if paired == 'paired':
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -92,12 +90,10 @@ else:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
                expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}"
diff --git a/workflows/fastqc_raw.smk b/workflows/fastqc_raw.smk
index 450b5bad..4bc609a1 100644
--- a/workflows/fastqc_raw.smk
+++ b/workflows/fastqc_raw.smk
@@ -14,15 +14,13 @@ if paired == 'paired':
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -37,12 +35,10 @@ else:
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/fastqc_trim.smk b/workflows/fastqc_trim.smk
index 9e4316d6..d462555a 100644
--- a/workflows/fastqc_trim.smk
+++ b/workflows/fastqc_trim.smk
@@ -36,15 +36,13 @@ if paired == 'paired':
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                 expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -70,12 +68,10 @@ else:
     rule multiqc:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/multiqc.nf b/workflows/multiqc.nf
index ab31357d..a5165607 100644
--- a/workflows/multiqc.nf
+++ b/workflows/multiqc.nf
@@ -30,24 +30,22 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${COMBO}/${CONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${COMBO}"
     CONDITION_VAL="${CONDITION}"
-    mkdir -p "\$COLLECT"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
 
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
 
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
 
     MODS=""
@@ -56,7 +54,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 
diff --git a/workflows/multiqc.smk b/workflows/multiqc.smk
index abe2a823..42ec846d 100644
--- a/workflows/multiqc.smk
+++ b/workflows/multiqc.smk
@@ -13,15 +13,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
@@ -34,15 +32,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         if prededup:
@@ -58,15 +54,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo,type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"                    
         else:
             rule multiqc:
                 input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
@@ -79,15 +73,13 @@ if rundedup:
                         expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                         expand(rules.dedupbam.output.bam, file=samplecond(SAMPLES, config), combo=combo, type=["sorted", "sorted_unique"]),
                         versions = "LOGS/versions.txt"
-                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                        tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                        lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+                output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
                 log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
                 conda:  "qc.yaml"
                 container: "oras://jfallmann/monsda:qc"
                 threads: 1
                 params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-                shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+                shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     if paired == 'paired':
@@ -99,15 +91,13 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda:  "qc.yaml"
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
     else:
         rule multiqc:
@@ -118,12 +108,10 @@ else:
                     expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                     expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                     versions = "LOGS/versions.txt"
-            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                    tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                    lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+            output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
             log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
             conda:  "qc.yaml"
             container: "oras://jfallmann/monsda:qc"
             threads: 1
             params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-            shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+            shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/multiqc_rustqc.nf b/workflows/multiqc_rustqc.nf
index 89a6328b..fd217477 100644
--- a/workflows/multiqc_rustqc.nf
+++ b/workflows/multiqc_rustqc.nf
@@ -30,24 +30,22 @@ process mqc{
     touch $others
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
-    SCAN="\${LOGDIR}/${COMBO}/${CONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
-    VERSIONS="\${LOGDIR}/versions.txt"
-    EXTRA=""
     BASE_QC_DIR="${workflow.workDir}/../QC"
     COMBO_VAL="${COMBO}"
     CONDITION_VAL="${CONDITION}"
-    mkdir -p "\$COLLECT"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
 
-    for i in $others; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
 
     # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_COMBO="\${COMBO_VAL/rustqc/fastqc}"
-    FQ_DIR="\${BASE_QC_DIR}/\${FQ_COMBO}/\${CONDITION_VAL}"
-    if [[ "\$FQ_COMBO" != "\$COMBO_VAL" && -d "\$FQ_DIR" ]]; then
-        EXTRA="\$FQ_DIR"
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
     fi
 
     MODS=""
@@ -56,7 +54,7 @@ process mqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN" \$EXTRA
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 
diff --git a/workflows/multiqc_rustqc.smk b/workflows/multiqc_rustqc.smk
index b1b108eb..8505961e 100644
--- a/workflows/multiqc_rustqc.smk
+++ b/workflows/multiqc_rustqc.smk
@@ -5,15 +5,13 @@ if paired == 'paired':
                 expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                 versions = "LOGS/versions.txt"
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
@@ -22,12 +20,10 @@ else:
                 expand(rules.sam2bam.output.bam, file=samplecond(SAMPLES, config), combo=combo),
                 expand(rules.sam2bamuniq.output.uniqbam, file=samplecond(SAMPLES, config), combo=combo),
                 versions = "LOGS/versions.txt"
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
         params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; FQ_COMBO=$(echo {wildcards.combo} | sed 's/rustqc/fastqc/g'); FQ_DIR=QC/${{FQ_COMBO}}/{wildcards.condition}; if [ -d \"${{FQ_DIR}}\" ]; then echo ${{FQ_DIR}} >> {output.tmp}; for f in ${{FQ_DIR}}/*;do ln -sfnr \"$f\" $COLLECT/ 2>> {log} || cp -f \"$f\" $COLLECT/ 2>> {log};done; fi; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/premultiqc.nf b/workflows/premultiqc.nf
index 1190efe9..9241d4d0 100644
--- a/workflows/premultiqc.nf
+++ b/workflows/premultiqc.nf
@@ -42,13 +42,13 @@ process premultiqc{
     OUT=\${PWD}
     LOGDIR="${workflow.workDir}/../LOGS"
     SCAN="\${LOGDIR}/${CONDITION}"
-    COLLECT="\${SCAN}/MULTIQC/collect"
     VERSIONS="\${LOGDIR}/versions.txt"
-    mkdir -p "\$COLLECT"
 
-    for i in $samples; do
-        cp -f "\$i" "\$COLLECT"/
-    done
+    # All QC results of this condition are reported, no need to collect them first.
+    QC_DIR="${workflow.workDir}/../QC/${CONDITION}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
 
     MODS=""
     if [[ -f "\$VERSIONS" ]]; then
@@ -56,7 +56,7 @@ process premultiqc{
         cp -f "\$VERSIONS" "\$OUT"/
     fi
     export LC_ALL=C.UTF-8
-    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" "\$SCAN"
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
     """
 }
 
diff --git a/workflows/premultiqc.smk b/workflows/premultiqc.smk
index 979a066d..5070d9b2 100644
--- a/workflows/premultiqc.smk
+++ b/workflows/premultiqc.smk
@@ -5,24 +5,20 @@ if paired == 'paired':
     rule multiqc:
         input: expand("QC/{rawfile}_{read}_fastqc.zip", rawfile=list(SAMPLES), read=['R1','R2']),
                versions = "LOGS/versions.txt"
-        output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{condition}/tmp"),
-                lst = "QC/Multi/{condition}/qclist.txt"
+        output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.condition}; if [ -d QC/{wildcards.condition} ]; then SCAN=\"$SCAN QC/{wildcards.condition}\"; fi; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
         input: expand("QC/{rawfile}_fastqc.zip", rawfile=list(SAMPLES)),
                versions = "LOGS/versions.txt"
-        output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{condition}/tmp"),
-                lst = "QC/Multi/{condition}/qclist.txt"
+        output: html = report("QC/Multi/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/MULTIQC/multiqc/{condition}_multiqc.log"
         conda:  "qc.yaml"
         container: "oras://jfallmann/monsda:qc"
         threads: 1
-        shell:  "OUT=$(dirname {output.html}); SCAN=LOGS/{wildcards.condition}; COLLECT=$SCAN/MULTIQC/collect; mkdir -p $COLLECT $OUT; for i in {input};do case \"${{i}}\" in *versions.txt) continue;; esac; echo $(dirname \"${{i}}\") >> {output.tmp}; ln -sfnr \"${{i}}\" $COLLECT/ 2>> {log} || cp -f \"${{i}}\" $COLLECT/ 2>> {log};done; cat {output.tmp} |sort -u > {output.lst}; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.condition}; if [ -d QC/{wildcards.condition} ]; then SCAN=\"$SCAN QC/{wildcards.condition}\"; fi; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/rastqc_dedup.smk b/workflows/rastqc_dedup.smk
index 01b9c5a0..02401a01 100644
--- a/workflows/rastqc_dedup.smk
+++ b/workflows/rastqc_dedup.smk
@@ -36,15 +36,13 @@ if paired == 'paired':
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                 expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -70,12 +68,10 @@ else:
     rule multiqc:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
 		       expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/rastqc_dedup_trim.smk b/workflows/rastqc_dedup_trim.smk
index 1fb52a12..d10eaccb 100644
--- a/workflows/rastqc_dedup_trim.smk
+++ b/workflows/rastqc_dedup_trim.smk
@@ -47,15 +47,13 @@ if paired == 'paired':
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -92,12 +90,10 @@ else:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
                expand(rules.qc_dedup.output.o1, file=samplecond(SAMPLES, config), combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trim_dedup.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_trim_dedup_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trim_dedup.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}"
diff --git a/workflows/rastqc_raw.smk b/workflows/rastqc_raw.smk
index 48400866..a92df333 100644
--- a/workflows/rastqc_raw.smk
+++ b/workflows/rastqc_raw.smk
@@ -14,15 +14,13 @@ if paired == 'paired':
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -37,12 +35,10 @@ else:
 
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/rastqc_trim.smk b/workflows/rastqc_trim.smk
index 253bf1a1..272b235c 100644
--- a/workflows/rastqc_trim.smk
+++ b/workflows/rastqc_trim.smk
@@ -36,15 +36,13 @@ if paired == 'paired':
     rule multiqc:
         input:  expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), read=['R1','R2'], combo=combo),
                 expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), read=['R1','R2'], combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
 
 else:
     rule qc_raw:
@@ -70,12 +68,10 @@ else:
     rule multiqc:
         input: expand(rules.qc_raw.output.o1, rawfile=list(SAMPLES), combo=combo),
                expand(rules.qc_trimmed.output.o1, file=samplecond(SAMPLES, config), combo=combo)
-        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC"),
-                tmp = temp("QC/Multi/{combo}/{condition}/tmp"),
-                lst = "QC/Multi/{combo}/{condition}/qclist_trimmed_raw.txt"
+        output: html = report("QC/Multi/{combo}/{condition}/multiqc_report.html", category="QC")
         log:    "LOGS/{combo}/MULTIQC/multiqc/{condition}_multiqc_trimmed_raw.log"
         conda:  ""+QCENV+".yaml"
         container: "oras://jfallmann/monsda:"+QCENV+""
         threads: 1
         params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); for i in {input};do echo $(dirname \"${{i}}\") >> {output.tmp};done; cat {output.tmp} |sort -u > {output.lst};export LC_ALL=en_US.utf8; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT -l {output.lst} 2> {log}"
+        shell:  "OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}"
diff --git a/workflows/rustqc.nf b/workflows/rustqc.nf
index 05773373..7decbb9d 100644
--- a/workflows/rustqc.nf
+++ b/workflows/rustqc.nf
@@ -25,8 +25,7 @@ process rustqc_mapped{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("rustqc_summary.json") > 0)      "QC/${COMBO}/${CONDITION}/${file(filename).getParent().getName()}/rustqc_summary.json"
-        else                                                    "QC/${COMBO}/${CONDITION}/${filename}"
+        "QC/${COMBO}/${CONDITION}/"+filename.replaceFirst('^results/', '')
     }
 
     input:
@@ -34,13 +33,13 @@ process rustqc_mapped{
 
     output:
     path "results/**", emit: rustqc_results
-    path "results/rustqc_summary.json", emit: rustqc_json
+    path "results/*/rustqc_summary.json", emit: rustqc_json
 
     script:
     fn = file(bam).getSimpleName()
     anno = file("${workflow.workDir}/../${MAPANNO}")
     """
-    gzip -cdfq $anno > tmp_anno.gtf && $RUSTQCBIN rna $bam --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/rustqc_summary.json -o results/$fn $RUSTQCPARAMS && rm -f tmp_anno.gtf
+    mkdir -p results/$fn && gzip -cdfq $anno > tmp_anno.gtf && $RUSTQCBIN rna $bam --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/$fn/rustqc_summary.json -o results/$fn $RUSTQCPARAMS && rm -f tmp_anno.gtf
     """
 }
 

From 4c2f0c3c32925def31caeda3ffbea95934487f13 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 26 Aug 2026 14:09:59 +0200
Subject: [PATCH 46/80] added workaround for cases where umitools is invoked
 without extract

---
 workflows/umitools.nf  |  22 ++++++-
 workflows/umitools.smk | 143 +++++++++++++++++++++++++++--------------
 2 files changed, 114 insertions(+), 51 deletions(-)

diff --git a/workflows/umitools.nf b/workflows/umitools.nf
index 45133be5..3f918bbd 100644
--- a/workflows/umitools.nf
+++ b/workflows/umitools.nf
@@ -71,7 +71,27 @@ process extract_fq{
     path "ex.log", emit: logs
 
     script:
-    if (PAIRED == 'paired'){
+    if (EXTRACTPARAMS == ''){
+        if (PAIRED == 'paired'){
+            r1 = samples[0]
+            r2 = samples[1]
+            outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
+            outf2 = samples[1].getSimpleName()+"_dedup.fastq.gz"
+            """
+                echo 'EXTRACT unset, linking input fastq(s) as-is' > ex.log
+                ln -sf \$(readlink -f $r1) $outf
+                ln -sf \$(readlink -f $r2) $outf2
+            """
+        }
+        else{
+            outf = samples.getSimpleName()+"_dedup.fastq.gz"
+            """
+                echo 'EXTRACT unset, linking input fastq(s) as-is' > ex.log
+                ln -sf \$(readlink -f $samples) $outf
+            """
+        }
+    }
+    else if (PAIRED == 'paired'){
         r1 = samples[0]
         r2 = samples[1]
         outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
diff --git a/workflows/umitools.smk b/workflows/umitools.smk
index 6a58376a..28885093 100644
--- a/workflows/umitools.smk
+++ b/workflows/umitools.smk
@@ -1,6 +1,7 @@
 DEDUPBIN, DEDUPENV = env_bin_from_config(config, 'DEDUP')
 
 wlparams = tool_params(SAMPLES[0], None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('WHITELIST')
+eparams = tool_params(SAMPLES[0], None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT')
 
 wildcard_constraints:
     type = "sorted|sorted_unique"
@@ -20,34 +21,57 @@ if paired == 'paired':
                     dedup = DEDUPBIN
             shell:  "mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.wl}"
 
-        rule extract:
-            input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
-                    r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
-                    wl = rules.whitelist.output.wl
-            output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                    o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
-                    td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
-            conda: ""+DEDUPENV+".yaml"
-            container: "oras://jfallmann/monsda:"+DEDUPENV+""
-            threads: 1
-            params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
-                    dedup = DEDUPBIN
-            shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}"
+        if eparams:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        wl = rules.whitelist.output.wl
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                        o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                conda: ""+DEDUPENV+".yaml"
+                container: "oras://jfallmann/monsda:"+DEDUPENV+""
+                threads: 1
+                params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
+                        dedup = DEDUPBIN
+                shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}"
+        else:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        wl = rules.whitelist.output.wl
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                        o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                threads: 1
+                shell:  "mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log} && ln -sf $(readlink -f {input.r2}) {output.o2} 2>> {log}"
     else:
-        rule extract:
-            input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
-                    r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
-            output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
-                    o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
-                    td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
-            conda: ""+DEDUPENV+".yaml"
-            container: "oras://jfallmann/monsda:"+DEDUPENV+""
-            threads: 1
-            params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
-                    dedup = DEDUPBIN
-            shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}"
+        if eparams:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                        o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                conda: ""+DEDUPENV+".yaml"
+                container: "oras://jfallmann/monsda:"+DEDUPENV+""
+                threads: 1
+                params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
+                        dedup = DEDUPBIN
+                shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}"
+        else:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}_R1.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        r2 = lambda wildcards: "FASTQ/{rawfile}_R2.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_R1_dedup.fastq.gz",
+                        o2 = "DEDUP_FASTQ/{combo}/{file}_R2_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                threads: 1
+                shell:  "mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log} && ln -sf $(readlink -f {input.r2}) {output.o2} 2>> {log}"
 
 else:
     if wlparams:
@@ -63,31 +87,50 @@ else:
                     dedup = DEDUPBIN
             shell:  "mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.wl}"
 
-        rule extract:
-            input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
-                    wl = rules.whitelist.output.wl
-            output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
-                    td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
-            conda: ""+DEDUPENV+".yaml"
-            container: "oras://jfallmann/monsda:"+DEDUPENV+""
-            threads: 1
-            params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
-                    dedup = DEDUPBIN
-            shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --stdout={output.o1}"
+        if eparams:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        wl = rules.whitelist.output.wl
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                conda: ""+DEDUPENV+".yaml"
+                container: "oras://jfallmann/monsda:"+DEDUPENV+""
+                threads: 1
+                params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
+                        dedup = DEDUPBIN
+                shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --stdout={output.o1}"
+        else:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0]),
+                        wl = rules.whitelist.output.wl
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                threads: 1
+                shell:  "mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log}"
 
     else:
-        rule extract:
-            input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
-            output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
-                    td = temp(directory("TMP/UMIEX/{combo}/{file}"))
-            log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
-            conda: ""+DEDUPENV+".yaml"
-            container: "oras://jfallmann/monsda:"+DEDUPENV+""
-            threads: 1
-            params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
-                    dedup = DEDUPBIN
-            shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.o1}"
+        if eparams:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                conda: ""+DEDUPENV+".yaml"
+                container: "oras://jfallmann/monsda:"+DEDUPENV+""
+                threads: 1
+                params: dpara = lambda wildcards: tool_params(wildcards.file, None, config, "DEDUP", DEDUPENV)['OPTIONS'].get('EXTRACT', ""),
+                        dedup = DEDUPBIN
+                shell:  "mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.o1}"
+        else:
+            rule extract:
+                input:  r1 = lambda wildcards: "FASTQ/{rawfile}.fastq.gz".format(rawfile=[x for x in SAMPLES if x.split(os.sep)[-1] in wildcards.file][0])
+                output: o1 = "DEDUP_FASTQ/{combo}/{file}_dedup.fastq.gz",
+                        td = temp(directory("TMP/UMIEX/{combo}/{file}"))
+                log:   "LOGS/{combo}/{file}/DEDUP/umitools/dedup_extract.log"
+                threads: 1
+                shell:  "mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log}"
 
 if paired == 'paired':
     rule dedupbam:

From 4c8d36519a30f7e921c9abb05a482c85b81cbdb7 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 27 Aug 2026 10:45:52 +0200
Subject: [PATCH 47/80] shebang format

---
 scripts/Analysis/build_count_table_simple.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/Analysis/build_count_table_simple.py b/scripts/Analysis/build_count_table_simple.py
index 28a0204e..c57de736 100755
--- a/scripts/Analysis/build_count_table_simple.py
+++ b/scripts/Analysis/build_count_table_simple.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#! /usr/bin/env python3
 
 import argparse
 import gzip

From 3f1063b954d3001b39bfa67d5705a7239e44f930 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 27 Aug 2026 13:23:58 +0200
Subject: [PATCH 48/80] hardened MDS plots for fewer samples, skipping if not
 enough instead of breaking

---
 scripts/Analysis/DE/EDGER.R | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 933fc16b..1b5dd818 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -29,6 +29,16 @@ print(args)
 libp <- paste0(gsub("/bin/conda", "/envs/monsda", Sys.getenv("CONDA_EXE")), "/share/MONSDA/scripts/lib/_lib.R")
 source(libp)
 
+## plotMDS needs at least 3 samples/columns, fall back to a placeholder plot otherwise
+safe_plotMDS <- function(dgeobj, ...) {
+    if (ncol(dgeobj) < 3) {
+        plot.new()
+        text(0.5, 0.5, paste0("MDS plot skipped: only ", ncol(dgeobj), " sample(s), need at least 3"), cex = 0.8)
+    } else {
+        plotMDS(dgeobj, ...)
+    }
+}
+
 ### SCRIPT
 print(paste("Run EdgeR DE with ", availablecores, " cores", sep = ""))
 
@@ -132,7 +142,7 @@ write.table(as.data.frame(tmm), gzfile(paste("Tables/DE", "EDGER", combi, "DataS
 ## create file MDS-plot with and without summarized replicates
 out <- paste("Figures/DE", "EDGER", combi, "DataSet", "figure", "AllConditionsMDS.png", sep = "_")
 png(out, width=1900, height=1200, res=300)
-plotMDS(dge, col = as.numeric(dge$samples$group), cex = 1)
+safe_plotMDS(dge, col = as.numeric(dge$samples$group), cex = 1)
 dev.off()
 
 ## estimate Dispersion
@@ -238,7 +248,7 @@ for (contrast in comparison[[1]]) {
         ## create file MDS-plot with and without summarized replicates
         out <- paste("Figures/DE", "EDGER", combi, contrast_name, "figure", "MDS_norm.png", sep = "_")
         png(out, width=1900, height=1200, res=300)
-        print(plotMDS(dge_norm, col = as.numeric(dge_norm$samples$group), cex = 1))
+        print(safe_plotMDS(dge_norm, col = as.numeric(dge_norm$samples$group), cex = 1))
         dev.off()
 
         ## estimate Dispersion
@@ -286,7 +296,7 @@ for (contrast in comparison[[1]]) {
     ## create file MDS-plot with and without summarized replicates
     out <- paste("Figures/DE", "EDGER", combi, contrast_name, "figure", "MDS.png", sep = "_")
     png(out, width=1900, height=1200, res=300)
-    print(plotMDS(dge, col = as.numeric(dge$samples$group), cex = 1))
+    print(safe_plotMDS(dge, col = as.numeric(dge$samples$group), cex = 1))
     dev.off()
 
     ## estimate Dispersion

From 4cbce3dc3f44581ed57d7bfb74b4a45c87471ba8 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 27 Aug 2026 15:26:58 +0200
Subject: [PATCH 49/80] single replicate fix for edger

---
 scripts/Analysis/DE/EDGER.R | 48 ++++++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 8 deletions(-)

diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 1b5dd818..350c29f3 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -39,6 +39,15 @@ safe_plotMDS <- function(dgeobj, ...) {
     }
 }
 
+## When a contrast has no residual degrees of freedom (e.g. two groups with a single sample each),
+## edgeR cannot estimate dispersion from the data at all (estimateDisp/glmQLFit fail with
+## "No residual df"/"NA dispersions not allowed"/"Could not estimate prior df"). Fall back to a
+## fixed, typical BCV and edgeR's classic exactTest for that contrast only, same as EDGER_no_rep.R.
+FALLBACK_BCV <- 0.4
+no_residual_df <- function(design) {
+    (nrow(design) - qr(design)$rank) <= 0
+}
+
 ### SCRIPT
 print(paste("Run EdgeR DE with ", availablecores, " cores", sep = ""))
 
@@ -299,22 +308,39 @@ for (contrast in comparison[[1]]) {
     print(safe_plotMDS(dge, col = as.numeric(dge$samples$group), cex = 1))
     dev.off()
 
-    ## estimate Dispersion
-    dge <- estimateDisp(dge, design, robust = TRUE)
+    no_rep <- no_residual_df(design)
+    if (no_rep) {
+        print(paste0("No residual degrees of freedom for contrast ", contrast_name, ": at least one group has no replicates, dispersion cannot be estimated from the data. Falling back to a fixed BCV of ", FALLBACK_BCV, " (edgeR exactTest) for this contrast."))
+    } else {
+        ## estimate Dispersion
+        dge <- estimateDisp(dge, design, robust = TRUE)
+    }
 
     ## create file BCV-plot - visualizing estimated dispersions
     out <- paste("Figures/DE", "EDGER", combi, contrast_name, "figure", "BCV.png", sep = "_")
     png(out, width=1900, height=1200, res=300)
-    print(plotBCV(dge))
+    if (no_rep) {
+        plot.new()
+        text(0.5, 0.5, paste0("BCV plot skipped: no replicates, using fixed BCV = ", FALLBACK_BCV), cex = 0.8)
+    } else {
+        print(plotBCV(dge))
+    }
     dev.off()
 
-    ## fitting a quasi-likelihood negative binomial generalized log-linear model to counts
-    fit <- glmQLFit(dge, design, robust = TRUE)
+    if (!no_rep) {
+        ## fitting a quasi-likelihood negative binomial generalized log-linear model to counts
+        fit <- glmQLFit(dge, design, robust = TRUE)
+    }
 
     ## create file quasi-likelihood-dispersion-plot
     out <- paste("Figures/DE", "EDGER", combi, contrast_name, "figure", "QLDisp.png", sep = "_")
     png(out, width=1900, height=1200, res=300)
-    print(plotQLDisp(fit))
+    if (no_rep) {
+        plot.new()
+        text(0.5, 0.5, "QLDisp plot skipped: no replicates", cex = 0.8)
+    } else {
+        print(plotQLDisp(fit))
+    }
     dev.off()
 
     tryCatch({
@@ -332,8 +358,14 @@ for (contrast in comparison[[1]]) {
         # }
         # contrast <- as.numeric(contrast[,1])
         
-        AvsB <- makeContrasts(TreatvsUntreat = paste("condition", A, sep = ""), levels = design)
-        qlf <- glmQLFTest(fit, contrast = AvsB) ## glm quasi-likelihood-F-Test
+        if (no_rep) {
+            qlf <- exactTest(dge, pair = c(B[1], A[1]), dispersion = FALLBACK_BCV^2, prior.count = 2) ## no replicates: fixed-BCV exact test
+            qlf$table$F <- NA
+            qlf$table <- qlf$table[, c("logFC", "logCPM", "F", "PValue")]
+        } else {
+            AvsB <- makeContrasts(TreatvsUntreat = paste("condition", A, sep = ""), levels = design)
+            qlf <- glmQLFTest(fit, contrast = AvsB) ## glm quasi-likelihood-F-Test
+        }
         # add comp object to list for image
         comparison_objs[[contrast_name]] <- qlf
 

From b8bf48a42a8b606711174375fa50f1d03fe39dbd Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 31 Aug 2026 11:35:03 +0200
Subject: [PATCH 50/80] multiqc version bump, multiple fixes have been
 published

---
 envs/fastqc.yaml | 2 +-
 envs/rastqc.yaml | 2 +-
 envs/rustqc.yaml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/envs/fastqc.yaml b/envs/fastqc.yaml
index 8a22aa3d..7359edef 100644
--- a/envs/fastqc.yaml
+++ b/envs/fastqc.yaml
@@ -3,5 +3,5 @@ channels:
 - bioconda
 - conda-forge
 dependencies:
-- multiqc =1.21
+- multiqc =1.35
 - fastqc =0.12.1
diff --git a/envs/rastqc.yaml b/envs/rastqc.yaml
index 6610a1b3..9c97adde 100644
--- a/envs/rastqc.yaml
+++ b/envs/rastqc.yaml
@@ -3,5 +3,5 @@ channels:
 - bioconda
 - conda-forge
 dependencies:
-- multiqc =1.21
+- multiqc =1.35
 - rastqc =0.1.0
diff --git a/envs/rustqc.yaml b/envs/rustqc.yaml
index 5f268a0f..f47198a7 100644
--- a/envs/rustqc.yaml
+++ b/envs/rustqc.yaml
@@ -4,4 +4,4 @@ channels:
 - conda-forge
 dependencies:
 - rustqc =0.2.1
-- multiqc =1.21
+- multiqc =1.35

From f4e184571f7d05ba61ac3a990854e08ae4027ac0 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 31 Aug 2026 14:04:01 +0200
Subject: [PATCH 51/80] multiqc module fix

---
 MONSDA/Versions.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/MONSDA/Versions.py b/MONSDA/Versions.py
index 906ad039..ec24b8e1 100644
--- a/MONSDA/Versions.py
+++ b/MONSDA/Versions.py
@@ -25,7 +25,9 @@
 )
 
 # Mapping of tool/package name to the corresponding MultiQC module name(s),
-# names have to match the modules of MultiQC exactly, including case,
+# names have to match the modules of MultiQC exactly, including case, since
+# MultiQC 1.35 all module names are lowercase, e.g. featurecounts not
+# featureCounts,
 # tools without a MultiQC module are not listed, tools reporting the output of
 # several other tools, like rustqc, map to all modules they produce output for
 MULTIQC_MODULES = {
@@ -36,7 +38,7 @@
     "cutadapt": "cutadapt",
     "fastp": "fastp",
     "fastqc": "fastqc",
-    "featurecounts": "featureCounts",
+    "featurecounts": "featurecounts",
     "hisat2": "hisat2",
     "htseq": "htseq",
     "kallisto": "kallisto",
@@ -48,7 +50,7 @@
     "rseqc": "rseqc",
     "rustqc": (
         "custom_content",
-        "featureCounts",
+        "featurecounts",
         "preseq",
         "qualimap",
         "rseqc",
@@ -57,7 +59,7 @@
     "salmon": "salmon",
     "samtools": "samtools",
     "star": "star",
-    "subread": "featureCounts",
+    "subread": "featurecounts",
     "trimgalore": "cutadapt",
     "trim-galore": "cutadapt",
     "trimmomatic": "trimmomatic",

From 84454a9b7af573992177bc1f2ea5308db1261b73 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 31 Aug 2026 14:51:14 +0200
Subject: [PATCH 52/80] postprocessing fix for combo/scombo in some affected
 worklows

---
 ...c-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk | 6 +++---
 workflows/alevinfry.smk                                     | 4 ++--
 workflows/oarfish.smk                                       | 2 +-
 workflows/salmon.smk                                        | 6 ++++--
 workflows/simpleaf.smk                                      | 4 ++--
 workflows/starfusion.smk                                    | 6 +++---
 6 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
index 2acc1d57..07dde04f 100644
--- a/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
+++ b/tests/golden/config_FUSIONS/smk/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subsnake.smk
@@ -353,8 +353,8 @@ if not fastqmode:
 else:
     if paired == 'paired':
         rule starfusion:
-            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
-                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+            input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                    r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
@@ -367,7 +367,7 @@ else:
             shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"
     else:
         rule starfusion:
-            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+            input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
diff --git a/workflows/alevinfry.smk b/workflows/alevinfry.smk
index 520d47eb..94659310 100644
--- a/workflows/alevinfry.smk
+++ b/workflows/alevinfry.smk
@@ -18,8 +18,8 @@ rule generate_t2g:
     shell:  "mkdir -p $(dirname {output.t2g}); zcat {input.anno} | awk 'BEGIN{{FS=\"\\t\";OFS=\"\\t\"}} $3==\"transcript\"{{match($9,/transcript_id \"[^\"]+\"/); t=substr($9,RSTART+15,RLENGTH-16); match($9,/gene_id \"[^\"]+\"/); g=substr($9,RSTART+9,RLENGTH-10); print t,g}}' > {output.t2g} 2> {log}"
 
 rule counting:
-    input:  rad = "MAPPED/{combo}/{file}",
-            radfile = "MAPPED/{combo}/{file}/map.rad",
+    input:  rad = expand("MAPPED/{scombo}/{{file}}", scombo=scombo),
+            radfile = expand("MAPPED/{scombo}/{{file}}/map.rad", scombo=scombo),
             t2g = rules.generate_t2g.output.t2g
     output: cnts = report("COUNTS/{combo}/{file}/alevin/quants_mat.mtx.gz", category="COUNTING"),
             ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
diff --git a/workflows/oarfish.smk b/workflows/oarfish.smk
index 58ec0c9b..c8b16198 100644
--- a/workflows/oarfish.smk
+++ b/workflows/oarfish.smk
@@ -9,7 +9,7 @@ rule themall:
     input:  expand("COUNTS/{combo}/{file}_counts.sf.gz", combo=combo, file=samplecond(SAMPLES, config))
 
 rule mapping:
-    input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+    input:  bam = expand("MAPPED/{scombo}/{{file}}_mapped_sorted.bam", scombo=scombo),
             anno = ANNOTATION,
             fa = REFERENCE
     output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
diff --git a/workflows/salmon.smk b/workflows/salmon.smk
index c9e01007..f13b3bb4 100644
--- a/workflows/salmon.smk
+++ b/workflows/salmon.smk
@@ -27,7 +27,7 @@ rule salmon_index:
 
 if bammode == 'transcriptome':
     rule mapping:
-        input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+        input:  bam = expand("MAPPED/{scombo}/{{file}}_mapped_sorted.bam", scombo=scombo),
                 fa = REFERENCE
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
                 ctsdir = report(directory("COUNTS/{combo}/{file}"), category="COUNTING")
@@ -43,7 +43,7 @@ if bammode == 'transcriptome':
 
 elif bammode == 'genome':
     rule mapping:
-        input:  bam = "MAPPED/{combo}/{file}_mapped_sorted.bam",
+        input:  bam = expand("MAPPED/{scombo}/{{file}}_mapped_sorted.bam", scombo=scombo),
                 anno = ANNOTATION,
                 fa = REFERENCE
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
@@ -59,6 +59,8 @@ elif bammode == 'genome':
         shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} quant -p {threads} -a {params.nbam} --annotation {input.anno} --genome {input.fa} {params.cpara} -o {output.ctsdir} &>> {log} && rm -f {params.nbam} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
 
 elif paired == 'paired':
+    rule mapping:
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
                 r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
                 uidx = rules.salmon_index.output.uidx[0]
         output: cnts = report("COUNTS/{combo}/{file}_counts.sf.gz", category="COUNTING"),
diff --git a/workflows/simpleaf.smk b/workflows/simpleaf.smk
index cb0465da..c4413956 100644
--- a/workflows/simpleaf.smk
+++ b/workflows/simpleaf.smk
@@ -26,8 +26,8 @@ rule generate_index:
 
 if paired == 'paired' or paired == 'singlecell':
     rule counting:
-        input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
-                r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+        input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
                 idx = rules.generate_index.output.idx,
                 dummy = rules.generate_index.output.idxfile
         output: cnts = report("COUNTS/{combo}/{file}/af_quant/alevin/quants_mat.mtx.gz", category="COUNTING"),
diff --git a/workflows/starfusion.smk b/workflows/starfusion.smk
index 865d889a..e87d1e2e 100644
--- a/workflows/starfusion.smk
+++ b/workflows/starfusion.smk
@@ -58,8 +58,8 @@ if not fastqmode:
 else:
     if paired == 'paired':
         rule starfusion:
-            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_R1_trimmed.fastq.gz",
-                    r2 = "TRIMMED_FASTQ/{combo}/{file}_R2_trimmed.fastq.gz",
+            input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R1_trimmed.fastq.gz", scombo=scombo),
+                    r2 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_R2_trimmed.fastq.gz", scombo=scombo),
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"
@@ -72,7 +72,7 @@ else:
             shell:  "OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}"
     else:
         rule starfusion:
-            input:  r1 = "TRIMMED_FASTQ/{combo}/{file}_trimmed.fastq.gz",
+            input:  r1 = expand("TRIMMED_FASTQ/{scombo}/{{file}}_trimmed.fastq.gz", scombo=scombo),
                     lib = ctat_lib_input
             output: preds = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.tsv",
                     abridged = "FUSIONS/{combo}/{file}/star-fusion.fusion_predictions.abridged.tsv"

From ae6dfa8bafcbaaf682efc760f9fa788bd7e3f08e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 31 Aug 2026 16:22:44 +0200
Subject: [PATCH 53/80] multiple fixes for other postprocessing steps, mostly
 input/output nameing and wildcard fixes, new test template and golden update

---
 MONSDA/Workflows.py                           |   8 +-
 ...-picard-star_FUSIONS_starfusion_subflow.nf |  77 +++++++--
 tests/test_templates.py                       | 153 ++++++++++++++++++
 workflows/alevinfry.nf                        |   9 +-
 workflows/annotatebed.smk                     |  23 ++-
 workflows/kallisto.nf                         |  39 +++--
 workflows/oarfish.nf                          |   9 +-
 workflows/salmon.nf                           |  46 ++++--
 workflows/simpleaf.nf                         |  11 +-
 workflows/starfusion.nf                       |  88 ++++++++--
 10 files changed, 400 insertions(+), 63 deletions(-)
 create mode 100644 tests/test_templates.py

diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index b6b00616..4757bdfe 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -2102,7 +2102,7 @@ def nf_fetch_params(
             if REF:
                 REFERENCE = REF
                 REFDIR = str(os.path.dirname(REFERENCE))
-            if XENV in ["salmon", "kallisto"]:
+            if XENV in ["salmon", "kallisto", "simpleaf"]:
                 IDX = XCONF.get("INDEX")
                 if IDX:
                     INDEX = IDX
@@ -2273,9 +2273,9 @@ def nf_fetch_params(
         retconf["FUSIONSREF"] = REFERENCE
         retconf["FUSIONSREFDIR"] = REFDIR
         retconf["FUSIONSANNO"] = ANNOTATION
-        retconf["FUSIONSLIB"] = (
-            FUSCONF.get(FUSENV, {}).get("OPTIONS", {}).get("INDEX", "")
-        )
+        retconf["FUSIONSLIB"] = FUSCONF.get(FUSENV, {}).get("OPTIONS", {}).get(
+            "INDEX", ""
+        ) or os.path.join(REFDIR, "CTAT", FUSENV)
 
     retconf["REFERENCE"] = REFERENCE
     retconf["REFDIR"] = REFDIR
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index d6b5168a..cbd7a4ec 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -33,8 +33,10 @@ params.gFUSREF = get_always('FUSIONSREF')
 params.gFUSREFDIR = "${workflow.workDir}/../"+get_always('FUSIONSREFDIR')
 params.gFUSANNO = get_always('FUSIONSANNO')
 params.gFUSLIB = get_always('FUSIONSLIB')
+params.gFUSLIBDIR = params.gFUSLIB.startsWith('/') ? params.gFUSLIB : "${workflow.workDir}/../"+params.gFUSLIB
 params.gFUSPARAMS = get_always('starfusion_params_FUSION') ?: ''
 params.gFUSBUILD = get_always('starfusion_params_BUILD') ?: ''
+params.gFUSFASTQ = (get_always('starfusion_params_FASTQ') ?: '').toString().toLowerCase() in ['1', 'true', 'yes']
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
@@ -55,13 +57,13 @@ process starfusion{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
-        else      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/${file(filename).getName()}"
+        else      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/"+filename.toString().replace('_starfusion/', '/')
     }
     input:
     path fls
     output:
     path "${fn}_starfusion/*", emit: fusions
-    path "log", emit: log
+    path "*.log", emit: log
     script:
     ref = fls[0]
     anno = fls[1]
@@ -70,22 +72,77 @@ process starfusion{
     od = fn+"_starfusion"
     ol = fn+".log"
     """
-    if [[ -f \"${params.gFUSLIB}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}\"; elif [[ -f \"${params.gFUSLIB}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIB}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} ${params.gFUSPARAMS} &>> log; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    if [[ -f \"${params.gFUSLIBDIR}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIBDIR}\"; elif [[ -f \"${params.gFUSLIBDIR}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIBDIR}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> ${ol}; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} ${params.gFUSPARAMS} &>> ${ol}; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> ${ol}; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    """
+}
+process starfusion_fastq{
+    conda "<REPO>/envs/${params.gFUSENV}"+".yaml"
+    container "oras://ghcr.io/jfallmann/monsda:"+"${params.gFUSENV}"+"-VERSION"
+    cpus params.gTHREADS
+	cache 'lenient'
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") > 0)        "LOGS/${params.gSCOMBO}/${params.gCONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
+        else      "FUSIONS/${params.gSCOMBO}/${params.gCONDITION}/"+filename.toString().replace('_starfusion/', '/')
+    }
+    input:
+    path fls
+    output:
+    path "${fn}_starfusion/*", emit: fusions
+    path "*.log", emit: log
+    script:
+    ref = fls[0]
+    anno = fls[1]
+    if (params.gPAIRED == 'paired'){
+        rs = fls[2..3].sort{ it.getName() }
+        reads = "--left_fq "+rs[0]+" --right_fq "+rs[1]
+        fn = file(rs[0]).getSimpleName().replaceAll(/_R[12]_trimmed/, "")
+    } else{
+        reads = "--left_fq "+fls[2]
+        fn = file(fls[2]).getSimpleName().replaceAll(/_trimmed/, "")
+    }
+    od = fn+"_starfusion"
+    ol = fn+".log"
+    """
+    if [[ -f \"${params.gFUSLIBDIR}/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIBDIR}\"; elif [[ -f \"${params.gFUSLIBDIR}/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"${params.gFUSLIBDIR}/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} ${params.gFUSBUILD} ) &> ${ol}; fi; ${params.gFUSBIN} --genome_lib_dir \$CTAT ${reads} --output_dir ${od} --CPU ${task.cpus} ${params.gFUSPARAMS} &>> ${ol}; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
     """
 }
 workflow FUSIONS{ 
     take: collection
     main:
-    MAPPEDSAMPLES = params.gLONGSAMPLES.collect{
-        element -> return "${workflow.workDir}/../MAPPED/${params.gCOMBO}/"+element+"*.Chimeric.out.junction"
-    }
-    mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())  
     annofile = Channel.fromPath(params.gFUSANNO)
     genomefile = Channel.fromPath(params.gFUSREF)
-    starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+    if (params.gFUSFASTQ){
+        if (params.gPAIRED == 'paired'){
+            TRIMSAMPLES = params.gLONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+            }
+        } else{
+            TRIMSAMPLES = params.gLONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_trimmed.fastq.gz"
+            }
+        }
+        trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
+        if (params.gPAIRED == 'paired'){
+            starfusion_fastq(genomefile.combine(annofile.combine(trimsamples_ch.collate(2))))
+        } else{
+            starfusion_fastq(genomefile.combine(annofile.combine(trimsamples_ch.collate(1))))
+        }
+        outfusions = starfusion_fastq.out.fusions
+        outlogs = starfusion_fastq.out.log
+    }
+    else{
+        MAPPEDSAMPLES = params.gLONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../MAPPED/${params.gCOMBO}/"+element+"*.Chimeric.out.junction"
+        }
+        mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())
+        starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+        outfusions = starfusion.out.fusions
+        outlogs = starfusion.out.log
+    }
     emit:
-    fusions = starfusion.out.fusions
-    logs = starfusion.out.log
+    fusions = outfusions
+    logs = outlogs
 }
 
 
diff --git a/tests/test_templates.py b/tests/test_templates.py
new file mode 100644
index 00000000..f2457da5
--- /dev/null
+++ b/tests/test_templates.py
@@ -0,0 +1,153 @@
+"""Static convention checks on the workflow templates.
+
+These do not need snakemake, nextflow or any tool binary, they only read the
+templates in ``workflows/``. Each check corresponds to a class of bug that has
+already shipped at least once, see the docstrings of the individual tests.
+"""
+
+import re
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[1]
+WORKFLOWS = REPO / "workflows"
+
+UPSTREAM = "(?:MAPPED|TRIMMED_FASTQ|DEDUP_FASTQ|UNMAPPED)"
+POSTDIR = re.compile(r'"(?:COUNTS|DE|DEU|DAS|DTU|PEAKS|TRACKS|FUSIONS|CIRCS|BED)/')
+
+SECTION = re.compile(r"^\s*(\w+):")
+SECTION_KEYS = {
+    "input", "output", "log", "params", "conda", "container", "threads",
+    "shell", "run", "script", "message", "priority", "resources", "benchmark",
+    "group", "retries", "wildcard_constraints", "shadow", "envmodules",
+    "cache", "default_target", "localrule", "wrapper", "notebook",
+}
+EXPAND = re.compile(r'expand\(\s*(?:f?")([^"]*)"\s*,\s*([^)]*)\)')
+RULEHEAD = re.compile(r"^(\s*)(?:rule|checkpoint)\s+(\w+)\s*:\s*$")
+
+NFWORKFLOW = re.compile(
+    r"^workflow\s+(?:COUNTING|DE|DEU|DAS|DTU|PEAKS|TRACKS|FUSIONS|CIRCS)\s*\{"
+)
+NFUPSTREAM = re.compile(UPSTREAM + r"/\$\{SCOMBO\}")
+
+
+def _postprocess_smk():
+    """Templates that write into a postprocessing result directory."""
+    return sorted(p for p in WORKFLOWS.glob("*.smk") if POSTDIR.search(p.read_text()))
+
+
+def _postprocess_nf():
+    """Templates that define a postprocessing sub-workflow."""
+    out = []
+    for path in sorted(WORKFLOWS.glob("*.nf")):
+        lines = path.read_text().split("\n")
+        start = next((i for i, l in enumerate(lines) if NFWORKFLOW.match(l)), None)
+        if start is not None:
+            out.append((path, lines, start))
+    return out
+
+
+def test_postprocess_smk_inputs_use_scombo():
+    """Upstream inputs of a postprocessing rule live under the mapping combo.
+
+    In a postprocessing sub-workflow ``combo`` is ``<mappingcombo>/<tool>`` and
+    ``scombo`` is ``<mappingcombo>``, so anything read back from ``MAPPED/``,
+    ``TRIMMED_FASTQ/`` or ``DEDUP_FASTQ/`` has to be expanded with ``scombo``.
+    Using ``{combo}`` there looks for the files under a subdirectory named after
+    the postprocessing tool, which never exists.
+    """
+    bad = []
+    for path in _postprocess_smk():
+        section = None
+        for lineno, line in enumerate(path.read_text().split("\n"), 1):
+            if line.lstrip().startswith("#"):
+                continue
+            match = SECTION.match(line)
+            if match and match.group(1) in SECTION_KEYS:
+                section = match.group(1)
+            elif line and not line[0].isspace():
+                section = None
+            if section != "input":
+                continue
+            for call in EXPAND.finditer(line):
+                pattern, kwargs = call.group(1), call.group(2)
+                for placeholder in re.findall(UPSTREAM + r"/\{(s?combo)\}", pattern):
+                    bound = re.search(r"\b%s\s*=\s*(\w+)" % placeholder, kwargs)
+                    if (bound.group(1) if bound else None) != "scombo":
+                        bad.append(
+                            f"{path.name}:{lineno}: upstream {{{placeholder}}} is not "
+                            f"bound to scombo"
+                        )
+            if re.search(UPSTREAM + r"/\{combo\}", EXPAND.sub("", line)):
+                bad.append(
+                    f"{path.name}:{lineno}: upstream path uses {{combo}}, expand it "
+                    f"with scombo instead: {line.strip()[:80]}"
+                )
+    assert not bad, "postprocessing inputs read from the wrong combo:\n" + "\n".join(bad)
+
+
+def test_smk_rules_have_a_body():
+    """A rule header directly followed by another header is a copy/paste slip.
+
+    ``annotatebed.smk`` carried a duplicated ``rule BamToBed:`` line, which the
+    snakemake parser happily accepts, silently dropping one of the two.
+    """
+    bad = []
+    for path in sorted(WORKFLOWS.glob("*.smk")):
+        previous = None
+        for lineno, line in enumerate(path.read_text().split("\n"), 1):
+            if not line.strip() or line.lstrip().startswith("#"):
+                continue
+            match = RULEHEAD.match(line)
+            if match and previous is not None:
+                bad.append(
+                    f"{path.name}:{lineno}: rule {match.group(2)!r} directly follows "
+                    f"rule header {previous!r}, the first one has no body"
+                )
+            previous = match.group(2) if match else None
+    assert not bad, "rule without a body:\n" + "\n".join(bad)
+
+
+def test_postprocess_nf_builds_its_own_channels():
+    """Postprocessing nextflow workflows must not consume ``collection``.
+
+    ``RunMONSDA`` calls every postprocessing sub-workflow as ``SUBWORK(dummy())``
+    where ``dummy`` is just ``LOGS/MONSDA.log``. A workflow that filters or maps
+    ``collection`` therefore ends up with an empty channel and silently runs on
+    no sample at all. The upstream files have to be listed from ``*SAMPLES``.
+    """
+    bad = []
+    for path, lines, start in _postprocess_nf():
+        body = [l for l in lines[start:] if not re.match(r"^\s*take:\s*collection", l)]
+        source = "\n".join(body)
+        if re.search(r"\bcollection\b", source):
+            bad.append(
+                f"{path.name}: consumes 'collection', which only ever carries the "
+                f"MONSDA log dummy"
+            )
+        if not re.search(r"\b\w*SAMPLES\b", source):
+            bad.append(f"{path.name}: builds no input channel from a *SAMPLES list")
+    assert not bad, "postprocessing workflow never reaches a sample:\n" + "\n".join(bad)
+
+
+def test_postprocess_nf_upstream_paths_use_combo():
+    """In nextflow the combo variables carry the opposite meaning.
+
+    ``--COMBO`` is the mapping combo and ``--SCOMBO`` is
+    ``<mappingcombo>/<tool>``, so upstream files are read from ``${COMBO}`` and
+    only results are published under ``${SCOMBO}``.
+    """
+    bad = []
+    for path, lines, start in _postprocess_nf():
+        for lineno, line in enumerate(lines[start:], start + 1):
+            if NFUPSTREAM.search(line):
+                bad.append(
+                    f"{path.name}:{lineno}: upstream path uses ${{SCOMBO}}, must be "
+                    f"${{COMBO}}: {line.strip()[:80]}"
+                )
+    assert not bad, "upstream nextflow path uses the wrong combo:\n" + "\n".join(bad)
+
+
+def test_checks_cover_all_templates():
+    """Guard against the selectors silently matching nothing."""
+    assert len(_postprocess_smk()) > 20
+    assert len(_postprocess_nf()) > 20
diff --git a/workflows/alevinfry.nf b/workflows/alevinfry.nf
index 957f1215..3221b75f 100644
--- a/workflows/alevinfry.nf
+++ b/workflows/alevinfry.nf
@@ -63,10 +63,15 @@ workflow COUNTING{
 
     main:
 
-    radsamples = collection.filter(~/map.rad/)
+    RADSAMPLES = LONGSAMPLES.collect{
+        element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"/map.rad"
+    }
+
+    radsamples_ch = Channel.fromPath(RADSAMPLES.sort())
+
     annofile = Channel.fromPath(COUNTANNO)
     generate_t2g(annofile)
-    alevinfry_quant(generate_t2g.out.t2g.combine(radsamples.map{it -> file(it).getParent()}))
+    alevinfry_quant(generate_t2g.out.t2g.combine(radsamples_ch.map{it -> file(it).getParent()}))
 
     emit:
     counts = alevinfry_quant.out.counts
diff --git a/workflows/annotatebed.smk b/workflows/annotatebed.smk
index 2da2c527..8034cabe 100644
--- a/workflows/annotatebed.smk
+++ b/workflows/annotatebed.smk
@@ -1,38 +1,38 @@
 rule themall:
-    input: expand("BED/{combo}/{file}_anno_seq_{type}_merged.bed.gz", file=samplecond(SAMPLES, config), type=['sorted','unique'])
+    input: expand("BED/{combo}/{file}_anno_seq_{type}_merged.bed.gz", combo=combo, file=samplecond(SAMPLES, config), type=['sorted','unique'])
 
 checklist = list()
 checklist2 = list()
 for file in samplecond(SAMPLES, config):
     for type in ['sorted','unique']:
-        checklist.append(os.path.isfile(os.path.abspath('TRACKS/'+file+'_mapped_'+type+'.bed.gz')) and not os.path.islink(os.path.abspath('TRACKS/'+file+'_mapped_'+type+'.bed.gz')))
-        checklist2.append(os.path.isfile(os.path.abspath('PEAKS/'+file+'_mapped_'+type+'.bed.gz')) and not os.path.islink(os.path.abspath('PEAKS/'+file+'_mapped_'+type+'.bed.gz')))
+        checklist.append(os.path.isfile(os.path.abspath(os.path.join('TRACKS', scombo, file+'_mapped_'+type+'.bed.gz'))) and not os.path.islink(os.path.abspath(os.path.join('TRACKS', scombo, file+'_mapped_'+type+'.bed.gz'))))
+        checklist2.append(os.path.isfile(os.path.abspath(os.path.join('PEAKS', scombo, file+'_mapped_'+type+'.bed.gz'))) and not os.path.islink(os.path.abspath(os.path.join('PEAKS', scombo, file+'_mapped_'+type+'.bed.gz'))))
 
 if all(checklist):
     rule BamToBed:
-        input:  "TRACKS/{combo}/{file}_mapped_{type}.bed.gz"
+        input:  expand("TRACKS/{scombo}/{{file}}_mapped_{{type}}.bed.gz", scombo=scombo)
         output: "BED/{combo}/{file}_mapped_{type}.bed.gz"
         log:    "LOGS/{combo}/{file}/PEAKS/bedtools/linkbed{type}.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
-        params: abs = lambda wildcards: os.path.abspath('TRACKS/'+wildcards.file+'_mapped_'+wildcards.type+'.bed.gz')
+        params: abs = lambda wildcards, input: os.path.abspath(input[0])
         shell:  "ln -s {params.abs} {output}"
 elif all(checklist2):
     rule BamToBed:
-        input:  "PEAKS/{combo}/{file}_mapped_{type}.bed.gz"
+        input:  expand("PEAKS/{scombo}/{{file}}_mapped_{{type}}.bed.gz", scombo=scombo)
         output: "BED/{combo}/{file}_mapped_{type}.bed.gz"
         log:    "LOGS/{combo}/{file}/PEAKS/bedtools/linkbed{type}.log"
         conda:  "base.yaml"
         container: "oras://jfallmann/monsda:base"
         threads: 1
-        params: abs = lambda wildcards: os.path.abspath('PEAKS/'+wildcards.file+'_mapped_'+wildcards.type+'.bed.gz')
+        params: abs = lambda wildcards, input: os.path.abspath(input[0])
         shell:  "ln -s {params.abs} {output}"
 else:
     if not stranded or stranded == 'fr':
         rule BamToBed:
-            input:  "MAPPED/{combo}/{file}_mapped_sorted.bam",
-                    "MAPPED/{combo}/{file}_mapped_sorted_unique.bam"
+            input:  expand("MAPPED/{scombo}/{{file}}_mapped_sorted.bam", scombo=scombo),
+                    expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo)
             output: "BED/{combo}/{file}_mapped_sorted.bed.gz",
                     "BED/{combo}/{file}_mapped_unique.bed.gz"
             log:    "LOGS/{combo}/{file}/PEAKS/bedtools/createbed.log"
@@ -42,9 +42,8 @@ else:
             shell:  "bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[0]} 2> {log} && bedtools bamtobed -split -i {input[1]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[1]} 2>> {log}"
     elif stranded and stranded == 'rf':
         rule BamToBed:
-        rule BamToBed:
-            input:  "MAPPED/{combo}/{file}_mapped_sorted.bam",
-                    "MAPPED/{combo}/{file}_mapped_sorted_unique.bam"
+            input:  expand("MAPPED/{scombo}/{{file}}_mapped_sorted.bam", scombo=scombo),
+                    expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo)
             output: "BED/{combo}/{file}_mapped_sorted.bed.gz",
                     "BED/{combo}/{file}_mapped_unique.bed.gz"
             log:    "LOGS/{combo}/{file}/PEAKS/bedtools/createbed.log"
diff --git a/workflows/kallisto.nf b/workflows/kallisto.nf
index d0c467a8..888c7c96 100644
--- a/workflows/kallisto.nf
+++ b/workflows/kallisto.nf
@@ -36,9 +36,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        rs = reads[1..2].sort()
-        r1 = rs[1]
-        r2 = rs[2]
+        rs = reads[0..1].sort{ it.getName() }
+        r1 = rs[0]
+        r2 = rs[1]
         a="Trimming_report.txt"
         b=file(r1).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
         c=file(r2).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
@@ -158,23 +158,44 @@ workflow COUNTING{
     main:
    
     checkidx = file(COUNTUIDX)
-    collection.filter(~/.fastq.gz/)
-    
+    checktrim = file("${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}")
+
+    if (PAIRED == 'paired'){
+        TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+        }
+    } else{
+        TRIMSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_trimmed.fastq.gz"
+        }
+    }
+
+    if (checktrim.exists()){
+        trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
+    } else{
+        if (PAIRED == 'paired'){
+            trim(samples_ch.collate(2))
+        } else{
+            trim(samples_ch.collate(1))
+        }
+        trimsamples_ch = trim.out.trim.flatten()
+    }
+
     if (checkidx.exists()){
         idxfile = Channel.fromPath(COUNTUIDX)
         if (PAIRED == 'paired'){
-            kallisto_quant(idxfile.combine(samples_ch.collate(2)))
+            kallisto_quant(idxfile.combine(trimsamples_ch.collate(2)))
         } else{
-            kallisto_quant(idxfile.combine(samples_ch.collate(1)))
+            kallisto_quant(idxfile.combine(trimsamples_ch.collate(1)))
         }        
     }
     else{
         genomefile = Channel.fromPath(COUNTREF)
         kallisto_idx(genomefile)
         if (PAIRED == 'paired'){
-            kallisto_quant(kallisto_idx.out.idx.combine(samples_ch.collate(2)))
+            kallisto_quant(kallisto_idx.out.idx.combine(trimsamples_ch.collate(2)))
         } else{
-            kallisto_quant(kallisto_idx.out.idx.combine(samples_ch.collate(1)))
+            kallisto_quant(kallisto_idx.out.idx.combine(trimsamples_ch.collate(1)))
         }
     }
 
diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
index 4cbb0f4c..cb3c09c2 100644
--- a/workflows/oarfish.nf
+++ b/workflows/oarfish.nf
@@ -44,8 +44,13 @@ workflow COUNTING{
 
     main:
 
-    bamsamples = collection.filter(~/.bam/)
-    oarfish_quant(bamsamples)
+    MAPPEDSAMPLES = LONGSAMPLES.collect{
+        element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"_mapped_sorted.bam"
+    }
+
+    mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())
+
+    oarfish_quant(mapsamples_ch.collate(1))
 
     emit:
     counts = oarfish_quant.out.counts
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index 1c0250ab..a1ec8b84 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -38,9 +38,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        rs = reads[1..2].sort()
-        r1 = rs[1]
-        r2 = rs[2]
+        rs = reads[0..1].sort{ it.getName() }
+        r1 = rs[0]
+        r2 = rs[1]
         a="Trimming_report.txt"
         b=file(r1).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
         c=file(r2).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
@@ -196,30 +196,56 @@ workflow COUNTING{
     main:
    
     if (BAMMODE?.length() > 0){
-        bamsamples = collection.filter(~/.bam/)
-        salmon_quant_bam(bamsamples)
+        MAPPEDSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"_mapped_sorted.bam"
+        }
+
+        mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())
+
+        salmon_quant_bam(mapsamples_ch.collate(1))
         outcounts = salmon_quant_bam.out.counts
         outlogs = salmon_quant_bam.out.logs
     }
     else{
         checkidx = file(COUNTUIDX)
-        collection.filter(~/.fastq.gz/)
+        checktrim = file("${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}")
+
+        if (PAIRED == 'paired'){
+            TRIMSAMPLES = LONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+            }
+        } else{
+            TRIMSAMPLES = LONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_trimmed.fastq.gz"
+            }
+        }
+
+        if (checktrim.exists()){
+            trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
+        } else{
+            if (PAIRED == 'paired'){
+                trim(samples_ch.collate(2))
+            } else{
+                trim(samples_ch.collate(1))
+            }
+            trimsamples_ch = trim.out.trim.flatten()
+        }
 
         if (checkidx.exists()){
             idxfile = Channel.fromPath(COUNTUIDX)
             if (PAIRED == 'paired'){
-                salmon_quant(idxfile.combine(samples_ch.collate(2)))
+                salmon_quant(idxfile.combine(trimsamples_ch.collate(2)))
             } else{
-                salmon_quant(idxfile.combine(samples_ch.collate(1)))
+                salmon_quant(idxfile.combine(trimsamples_ch.collate(1)))
             }        
         }
         else{
             genomefile = Channel.fromPath(COUNTREF)
             salmon_idx(genomefile)
             if (PAIRED == 'paired'){
-                salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(2)))
+                salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(2)))
             } else{
-                salmon_quant(salmon_idx.out.idx.combine(samples_ch.collate(1)))
+                salmon_quant(salmon_idx.out.idx.combine(trimsamples_ch.collate(1)))
             }
         }
         outcounts = salmon_quant.out.counts
diff --git a/workflows/simpleaf.nf b/workflows/simpleaf.nf
index f2eaa3e8..b4c0095e 100644
--- a/workflows/simpleaf.nf
+++ b/workflows/simpleaf.nf
@@ -82,17 +82,22 @@ workflow COUNTING{
     main:
 
     checkidx = file(COUNTUIDX)
-    collection.filter(~/.fastq.gz/)
+
+    TRIMSAMPLES = LONGSAMPLES.collect{
+        element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+    }
+
+    trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
 
     if (checkidx.exists()){
         idxfile = Channel.fromPath(COUNTUIDX)
-        simpleaf_quant(idxfile.combine(samples_ch.collate(2)))
+        simpleaf_quant(idxfile.combine(trimsamples_ch.collate(2)))
     }
     else{
         genomefile = Channel.fromPath(COUNTREF)
         annofile = Channel.fromPath(COUNTANNO)
         simpleaf_idx(genomefile, annofile)
-        simpleaf_quant(simpleaf_idx.out.idx.combine(samples_ch.collate(2)))
+        simpleaf_quant(simpleaf_idx.out.idx.combine(trimsamples_ch.collate(2)))
     }
 
     emit:
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index 0fb1af3c..d17a7f73 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -4,9 +4,11 @@ FUSREF = get_always('FUSIONSREF')
 FUSREFDIR = "${workflow.workDir}/../"+get_always('FUSIONSREFDIR')
 FUSANNO = get_always('FUSIONSANNO')
 FUSLIB = get_always('FUSIONSLIB')
+FUSLIBDIR = FUSLIB.startsWith('/') ? FUSLIB : "${workflow.workDir}/../"+FUSLIB
 
 FUSPARAMS = get_always('starfusion_params_FUSION') ?: ''
 FUSBUILD = get_always('starfusion_params_BUILD') ?: ''
+FUSFASTQ = (get_always('starfusion_params_FASTQ') ?: '').toString().toLowerCase() in ['1', 'true', 'yes']
 
 //FUSIONS PROCESSES
 
@@ -20,7 +22,7 @@ process starfusion{
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
         if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
-        else      "FUSIONS/${SCOMBO}/${CONDITION}/${file(filename).getName()}"
+        else      "FUSIONS/${SCOMBO}/${CONDITION}/"+filename.toString().replace('_starfusion/', '/')
     }
 
     input:
@@ -28,7 +30,7 @@ process starfusion{
 
     output:
     path "${fn}_starfusion/*", emit: fusions
-    path "log", emit: log
+    path "*.log", emit: log
 
     script:
     ref = fls[0]
@@ -39,7 +41,45 @@ process starfusion{
     ol = fn+".log"
     
     """
-    if [[ -f \"$FUSLIB/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB\"; elif [[ -f \"$FUSLIB/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIB/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> log; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> log; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> log; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> log; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    if [[ -f \"$FUSLIBDIR/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR\"; elif [[ -f \"$FUSLIBDIR/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> ${ol}; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> ${ol}; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> ${ol}; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    """
+}
+
+process starfusion_fastq{
+    conda "$FUSENV"+".yaml"
+    container "oras://jfallmann/monsda:"+"$FUSENV"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf(".log") > 0)        "LOGS/${SCOMBO}/${CONDITION}/FUSIONS/starfusion/${file(filename).getName()}"
+        else      "FUSIONS/${SCOMBO}/${CONDITION}/"+filename.toString().replace('_starfusion/', '/')
+    }
+
+    input:
+    path fls
+
+    output:
+    path "${fn}_starfusion/*", emit: fusions
+    path "*.log", emit: log
+
+    script:
+    ref = fls[0]
+    anno = fls[1]
+    if (PAIRED == 'paired'){
+        rs = fls[2..3].sort{ it.getName() }
+        reads = "--left_fq "+rs[0]+" --right_fq "+rs[1]
+        fn = file(rs[0]).getSimpleName().replaceAll(/_R[12]_trimmed/, "")
+    } else{
+        reads = "--left_fq "+fls[2]
+        fn = file(fls[2]).getSimpleName().replaceAll(/_trimmed/, "")
+    }
+    od = fn+"_starfusion"
+    ol = fn+".log"
+
+    """
+    if [[ -f \"$FUSLIBDIR/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR\"; elif [[ -f \"$FUSLIBDIR/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> ${ol}; fi; $FUSBIN --genome_lib_dir \$CTAT ${reads} --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> ${ol}; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
     """
 }
 
@@ -48,17 +88,43 @@ workflow FUSIONS{
 
     main:
 
-    MAPPEDSAMPLES = LONGSAMPLES.collect{
-        element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"*.Chimeric.out.junction"
-    }
-
-    mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())  
     annofile = Channel.fromPath(FUSANNO)
     genomefile = Channel.fromPath(FUSREF)
 
-    starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+    if (FUSFASTQ){
+        if (PAIRED == 'paired'){
+            TRIMSAMPLES = LONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+            }
+        } else{
+            TRIMSAMPLES = LONGSAMPLES.collect{
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_trimmed.fastq.gz"
+            }
+        }
+
+        trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
+
+        if (PAIRED == 'paired'){
+            starfusion_fastq(genomefile.combine(annofile.combine(trimsamples_ch.collate(2))))
+        } else{
+            starfusion_fastq(genomefile.combine(annofile.combine(trimsamples_ch.collate(1))))
+        }
+        outfusions = starfusion_fastq.out.fusions
+        outlogs = starfusion_fastq.out.log
+    }
+    else{
+        MAPPEDSAMPLES = LONGSAMPLES.collect{
+            element -> return "${workflow.workDir}/../MAPPED/${COMBO}/"+element+"*.Chimeric.out.junction"
+        }
+
+        mapsamples_ch = Channel.fromPath(MAPPEDSAMPLES.sort())
+
+        starfusion(genomefile.combine(annofile.combine(mapsamples_ch.collate(1))))
+        outfusions = starfusion.out.fusions
+        outlogs = starfusion.out.log
+    }
 
     emit:
-    fusions = starfusion.out.fusions
-    logs = starfusion.out.log
+    fusions = outfusions
+    logs = outlogs
 }

From 2f58130f42a66d70d881d40aebf0443ccbea7acf Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 1 Sep 2026 13:04:30 +0200
Subject: [PATCH 54/80] fixed oarfish cli arguments for newer version

---
 workflows/oarfish.nf  | 2 +-
 workflows/oarfish.smk | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
index cb3c09c2..ed19a714 100644
--- a/workflows/oarfish.nf
+++ b/workflows/oarfish.nf
@@ -35,7 +35,7 @@ process oarfish_quant{
     oz = fn+"/quant.sf.gz"
     ol = fn+"_counts.gz"
     """
-    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $COUNTANNO --reference $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
+    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $COUNTANNO --genome-fasta $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
     """
 }
 
diff --git a/workflows/oarfish.smk b/workflows/oarfish.smk
index c8b16198..26e8acb8 100644
--- a/workflows/oarfish.smk
+++ b/workflows/oarfish.smk
@@ -23,4 +23,4 @@ rule mapping:
             nbam = lambda wildcards, output: os.path.join(str(output.ctsdir), "namecollated.bam"),
             prefix = lambda wildcards, output: os.path.join(str(output.ctsdir), "oarfish"),
             linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-    shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {input.anno} --reference {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+    shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {input.anno} --genome-fasta {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"

From 9cf744eea5caf4da65ca1d756f7a3603d887bfb3 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 1 Sep 2026 17:20:14 +0200
Subject: [PATCH 55/80] argument fixes for salmon

---
 .gitignore                | 5 +++++
 workflows/salmonalign.nf  | 4 ++--
 workflows/salmonalign.smk | 4 ++--
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/.gitignore b/.gitignore
index 7d38c430..e4bbd90a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,11 @@
 #temps
 *~
 \#*
+
+# generated tool-audit run reports (tool_manifest.yaml and the *.txt dumps
+# under tests/tool_audit/ ARE tracked and reviewed, this is not)
+tests/tool_audit/*.json
+tests/tool_audit/.last_report.json
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
diff --git a/workflows/salmonalign.nf b/workflows/salmonalign.nf
index e92bb561..79850a90 100644
--- a/workflows/salmonalign.nf
+++ b/workflows/salmonalign.nf
@@ -86,7 +86,7 @@ process salmonalign_mapping{
         uf2 = fn+"_R2_unmapped.fastq.gz"
         lf = "salmonalign_"+fn+".log"
         """
-        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings -o $fn -1 $r1 -2 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings=/dev/stdout -o $fn -1 $r1 -2 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
         """
     }else{
         if (STRANDED == 'fr' || STRANDED == 'SF'){
@@ -102,7 +102,7 @@ process salmonalign_mapping{
         uf = fn+"_unmapped.fastq.gz"
         lf = "salmonalign_"+fn+".log"
         """
-        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings -o $fn -r $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings=/dev/stdout -o $fn -r $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
         """
     }
 }
diff --git a/workflows/salmonalign.smk b/workflows/salmonalign.smk
index 2c6c5513..fdc2cb7c 100644
--- a/workflows/salmonalign.smk
+++ b/workflows/salmonalign.smk
@@ -36,7 +36,7 @@ if paired == 'paired':
                 mapp = MAPPERBIN,
                 stranded = lambda x: '-l ISF' if (stranded == 'fr' or stranded == 'ISF') else '-l ISR' if (stranded == 'rf' or stranded == 'ISR') else '-l IU',
                 outdir = lambda wildcards: "MAPPED/"+wildcards.combo+"/"+wildcards.file+"_salmonalign"
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings -o {params.outdir} -1 {input.q1} -2 {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings=/dev/stdout -o {params.outdir} -1 {input.q1} -2 {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}"
 
 else:
     rule mapping:
@@ -52,4 +52,4 @@ else:
                 mapp = MAPPERBIN,
                 stranded = lambda x: '-l SF' if (stranded == 'fr' or stranded == 'SF') else '-l SR' if (stranded == 'rf' or stranded == 'SR') else '-l U',
                 outdir = lambda wildcards: "MAPPED/"+wildcards.combo+"/"+wildcards.file+"_salmonalign"
-        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings -o {params.outdir} -r {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"
+        shell: "set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings=/dev/stdout -o {params.outdir} -r {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}"

From f51864d43646a6cce2059e5e555554ce04c3e129 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 1 Sep 2026 17:20:54 +0200
Subject: [PATCH 56/80] added comprehensive test suite for cli arguments of all
 tools to check drifts for newer version

---
 tests/test_tool_audit.py                      |   40 +
 tests/tool_audit/README.md                    |  205 +++
 tests/tool_audit/audit_tool_flags.py          |  369 ++++
 tests/tool_audit/bwameth_help.txt             |   62 +
 tests/tool_audit/extract_workflow_commands.py |  114 ++
 tests/tool_audit/fixtures/README.md           |   25 +
 tests/tool_audit/fixtures/tiny.bam            |  Bin 0 -> 261 bytes
 tests/tool_audit/help/af_collate.txt          |   15 +
 tests/tool_audit/help/af_genpermit.txt        |   60 +
 tests/tool_audit/help/af_quant.txt            |   32 +
 tests/tool_audit/help/alevinfry.txt           |   18 +
 tests/tool_audit/help/bbduk_help.txt          |  320 ++++
 tests/tool_audit/help/ciri2.txt               |    2 +
 tests/tool_audit/help/cutadapt_help.txt       |  220 +++
 tests/tool_audit/help/dorado.txt              |    2 +
 tests/tool_audit/help/fastp_help.txt          |   90 +
 tests/tool_audit/help/fgumi.txt               |   27 +
 tests/tool_audit/help/guppy.txt               |    2 +
 tests/tool_audit/help/hisat2.txt              |  141 ++
 tests/tool_audit/help/kallisto.txt            |   19 +
 tests/tool_audit/help/kallisto_index.txt      |   21 +
 tests/tool_audit/help/kallisto_quant.txt      |   30 +
 tests/tool_audit/help/macs2.txt               |   57 +
 tests/tool_audit/help/macs2_callpeak.txt      |  282 +++
 tests/tool_audit/help/macs3.txt               |   39 +
 tests/tool_audit/help/macs3_callpeak.txt      |  300 ++++
 tests/tool_audit/help/minimap2_help.txt       |   56 +
 tests/tool_audit/help/picard_markdup.txt      |  278 +++
 tests/tool_audit/help/piranha_help.txt        |    2 +
 tests/tool_audit/help/piscem_build.txt        |   52 +
 tests/tool_audit/help/piscem_mapsc.txt        |  104 ++
 tests/tool_audit/help/rustqc.txt              |   12 +
 tests/tool_audit/help/rustqc_rna.txt          |  195 +++
 tests/tool_audit/help/salmon.txt              |   17 +
 tests/tool_audit/help/salmon_alevin.txt       |    8 +
 tests/tool_audit/help/salmon_index.txt        |   24 +
 tests/tool_audit/help/salmon_quant.txt        |  428 +++++
 tests/tool_audit/help/scyphy.txt              |    2 +
 tests/tool_audit/help/segemehl3_help.txt      |    2 +
 tests/tool_audit/help/segemehl_help.txt       |  109 ++
 tests/tool_audit/help/simpleaf.txt            |    2 +
 tests/tool_audit/help/sra.txt                 |   71 +
 tests/tool_audit/help/sra_help.txt            |   71 +
 tests/tool_audit/help/star.txt                |  928 ++++++++++
 tests/tool_audit/help/trimgalore.txt          |  347 ++++
 tests/tool_audit/help/trimgalore_help.txt     |  347 ++++
 tests/tool_audit/help/umicollapse.txt         |    4 +
 tests/tool_audit/help/umicollapse2.txt        |    4 +
 tests/tool_audit/help/umicollapse_bam.txt     |    4 +
 tests/tool_audit/help/umicollapse_fastq.txt   |    4 +
 tests/tool_audit/help/umitools.txt            |   29 +
 tests/tool_audit/help/umitools_dedup.txt      |  136 ++
 tests/tool_audit/help/umitools_extract.txt    |  111 ++
 tests/tool_audit/help/umitools_whitelist.txt  |  104 ++
 tests/tool_audit/nf_script_commands.txt       | 1535 +++++++++++++++++
 tests/tool_audit/smk_shell_commands.txt       | 1116 ++++++++++++
 tests/tool_audit/tool_manifest.yaml           |  380 ++++
 57 files changed, 8974 insertions(+)
 create mode 100644 tests/test_tool_audit.py
 create mode 100644 tests/tool_audit/README.md
 create mode 100755 tests/tool_audit/audit_tool_flags.py
 create mode 100644 tests/tool_audit/bwameth_help.txt
 create mode 100755 tests/tool_audit/extract_workflow_commands.py
 create mode 100644 tests/tool_audit/fixtures/README.md
 create mode 100644 tests/tool_audit/fixtures/tiny.bam
 create mode 100644 tests/tool_audit/help/af_collate.txt
 create mode 100644 tests/tool_audit/help/af_genpermit.txt
 create mode 100644 tests/tool_audit/help/af_quant.txt
 create mode 100644 tests/tool_audit/help/alevinfry.txt
 create mode 100644 tests/tool_audit/help/bbduk_help.txt
 create mode 100644 tests/tool_audit/help/ciri2.txt
 create mode 100644 tests/tool_audit/help/cutadapt_help.txt
 create mode 100644 tests/tool_audit/help/dorado.txt
 create mode 100644 tests/tool_audit/help/fastp_help.txt
 create mode 100644 tests/tool_audit/help/fgumi.txt
 create mode 100644 tests/tool_audit/help/guppy.txt
 create mode 100644 tests/tool_audit/help/hisat2.txt
 create mode 100644 tests/tool_audit/help/kallisto.txt
 create mode 100644 tests/tool_audit/help/kallisto_index.txt
 create mode 100644 tests/tool_audit/help/kallisto_quant.txt
 create mode 100644 tests/tool_audit/help/macs2.txt
 create mode 100644 tests/tool_audit/help/macs2_callpeak.txt
 create mode 100644 tests/tool_audit/help/macs3.txt
 create mode 100644 tests/tool_audit/help/macs3_callpeak.txt
 create mode 100644 tests/tool_audit/help/minimap2_help.txt
 create mode 100644 tests/tool_audit/help/picard_markdup.txt
 create mode 100644 tests/tool_audit/help/piranha_help.txt
 create mode 100644 tests/tool_audit/help/piscem_build.txt
 create mode 100644 tests/tool_audit/help/piscem_mapsc.txt
 create mode 100644 tests/tool_audit/help/rustqc.txt
 create mode 100644 tests/tool_audit/help/rustqc_rna.txt
 create mode 100644 tests/tool_audit/help/salmon.txt
 create mode 100644 tests/tool_audit/help/salmon_alevin.txt
 create mode 100644 tests/tool_audit/help/salmon_index.txt
 create mode 100644 tests/tool_audit/help/salmon_quant.txt
 create mode 100644 tests/tool_audit/help/scyphy.txt
 create mode 100644 tests/tool_audit/help/segemehl3_help.txt
 create mode 100644 tests/tool_audit/help/segemehl_help.txt
 create mode 100644 tests/tool_audit/help/simpleaf.txt
 create mode 100644 tests/tool_audit/help/sra.txt
 create mode 100644 tests/tool_audit/help/sra_help.txt
 create mode 100644 tests/tool_audit/help/star.txt
 create mode 100644 tests/tool_audit/help/trimgalore.txt
 create mode 100644 tests/tool_audit/help/trimgalore_help.txt
 create mode 100644 tests/tool_audit/help/umicollapse.txt
 create mode 100644 tests/tool_audit/help/umicollapse2.txt
 create mode 100644 tests/tool_audit/help/umicollapse_bam.txt
 create mode 100644 tests/tool_audit/help/umicollapse_fastq.txt
 create mode 100644 tests/tool_audit/help/umitools.txt
 create mode 100644 tests/tool_audit/help/umitools_dedup.txt
 create mode 100644 tests/tool_audit/help/umitools_extract.txt
 create mode 100644 tests/tool_audit/help/umitools_whitelist.txt
 create mode 100644 tests/tool_audit/nf_script_commands.txt
 create mode 100644 tests/tool_audit/smk_shell_commands.txt
 create mode 100644 tests/tool_audit/tool_manifest.yaml

diff --git a/tests/test_tool_audit.py b/tests/test_tool_audit.py
new file mode 100644
index 00000000..1a581d88
--- /dev/null
+++ b/tests/test_tool_audit.py
@@ -0,0 +1,40 @@
+"""Pytest wrapper around tests/tool_audit/audit_tool_flags.py.
+
+Skips (with a visible reason) unless run on a machine that has the
+`apptainer` binary on PATH and the expected container directory - this
+audit needs the real external-tool containers and cannot run in a bare CI
+checkout. See tests/tool_audit/README.md for the manual findings this
+automates and how to run it directly:
+
+    conda activate apptainer
+    python tests/tool_audit/audit_tool_flags.py
+"""
+
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "tool_audit"))
+
+CONTAINER_DIR = Path.home() / "Work2" / "Container" / "MONSDA"
+
+pytestmark = pytest.mark.skipif(
+    shutil.which("apptainer") is None or not CONTAINER_DIR.exists(),
+    reason=(
+        "requires 'apptainer' on PATH (conda activate apptainer) and "
+        f"containers under {CONTAINER_DIR}"
+    ),
+)
+
+
+def test_tool_flags_audit():
+    import audit_tool_flags
+
+    rc = audit_tool_flags.main([])
+    assert rc == 0, (
+        "tool CLI flag audit found drift/gaps - see printed table above "
+        "and tests/tool_audit/README.md"
+    )
diff --git a/tests/tool_audit/README.md b/tests/tool_audit/README.md
new file mode 100644
index 00000000..e61c1ac6
--- /dev/null
+++ b/tests/tool_audit/README.md
@@ -0,0 +1,205 @@
+# Tool option audit
+
+Purpose: cross-check hardcoded CLI flags in workflows/*.smk and *.nf against the
+actual `--help` output of each tool inside its container in
+~/Work2/Container/MONSDA (apptainer conda env), to catch flag drift like the
+oarfish `--reference` -> `--genome-fasta` rename fixed in workflows/oarfish.smk
+and workflows/oarfish.nf (commit pending on dev_1.5.0).
+
+Status: IN PROGRESS. This file is updated incrementally as tools are checked.
+
+## Automated audit
+
+The manual process below has been turned into a repeatable script,
+`audit_tool_flags.py`, driven by the declarative `tool_manifest.yaml`
+(one entry per tool, transcribing every finding in this file). Run it
+whenever containers or tool versions are updated:
+
+    source ~/anaconda3/etc/profile.d/conda.sh && conda activate apptainer
+    python tests/tool_audit/audit_tool_flags.py            # default: all tools
+    python tests/tool_audit/audit_tool_flags.py --tool oarfish --tool salmon
+    python tests/tool_audit/audit_tool_flags.py --strict    # also fail known gaps
+    python tests/tool_audit/audit_tool_flags.py --json-out /tmp/report.json
+
+It classifies every check as PASS, DRIFT (a hardcoded flag no longer
+matches the tool's own `--help`/behaviour - a real regression, always
+fails the run), GAP (container or binary missing - informational if
+already listed with `known_gap: true`, otherwise a hard failure), or SKIP
+(explicitly not applicable, e.g. Piranha's config-only params). Exit code
+is non-zero on any DRIFT or newly-appeared GAP.
+
+It is also collected by `pytest` via `tests/test_tool_audit.py`, which
+self-skips with a visible reason on any machine without `apptainer` and
+the container directory (mirrors the `multiqc`-not-installed note in
+AGENTS.md - this cannot run in a bare CI checkout).
+
+`tool_manifest.yaml` is the reviewable source of truth and must be updated
+by hand whenever a workflow's hardcoded flags change. Use
+`python tests/tool_audit/extract_workflow_commands.py --refresh` to
+regenerate `smk_shell_commands.txt`/`nf_script_commands.txt` as a reference
+while doing so, and `--check-manifest` to sanity-check that every
+`source_refs` entry in the manifest is still found in those dumps (catches
+the extractor itself silently breaking on new syntax, not shell semantics).
+The script never edits this README automatically - promote genuinely new
+findings into the prose sections below by hand after fixing them.
+
+## Method (manual, superseded by the script above for routine re-checks)
+    source ~/anaconda3/etc/profile.d/conda.sh && conda activate apptainer
+    apptainer exec ~/Work2/Container/MONSDA/<tool>-1.5.0.sif <binary> --help
+
+## Findings
+
+### oarfish (fixed, commit 2f58130)
+`--reference` renamed to `--genome-fasta` in the current oarfish binary
+(container oarfish-1.5.0.sif). `--genome-alignments` mode error was:
+`error: unexpected argument '--reference' found`.
+Fixed in workflows/oarfish.smk and workflows/oarfish.nf.
+
+### salmonalign (fixed)
+salmon in the container (salmon-1.5.0.sif) is salmon 2.5.1, a full Rust
+rewrite. `--writeMappings` now REQUIRES an explicit filename value
+(`-z, --writeMappings <WRITE_MAPPINGS>`), unlike the old C++ salmon where
+`--writeMappings` with no argument defaulted to writing SAM to stdout.
+workflows/salmonalign.smk and .nf relied on that old stdout-default behavior
+(`--writeMappings -o {outdir} ... | tee >(samtools ...)`), so the shell
+piped nothing into `tee` and the whole aligned/unmapped split silently
+produced empty streams (confirmed by reproducing with a minimal salmon index
++ single read: without a value clap errors
+`a value is required for '--writeMappings <WRITE_MAPPINGS>' but none was
+supplied`).
+Fix: use `--writeMappings=/dev/stdout`, confirmed to write valid SAM to
+stdout in salmon 2.5.1. Applied in workflows/salmonalign.smk (both PE/SE
+rules) and workflows/salmonalign.nf (both PE/SE processes).
+
+### salmon.smk / salmon_trim.smk (checked, no change needed)
+`-d/--decoy` for `salmon index`, `-a/--alignments`, `--annotation`,
+`--genome`, `--deterministic` for `salmon quant` (genome/transcriptome
+counting modes used by workflows/salmon.smk) all exist as-is in salmon
+2.5.1 `salmon quant --help`. No `--writeMappings` used there since it does
+not stream SAM to stdout (counts-only), so unaffected by the above.
+
+### kallisto (checked, no change needed)
+kallisto 0.51.0 in container. `-d/--d-list` (decoy), `-i`, `-t`, `-o`,
+`--single`, `-1/-2`/positional fastqs used in workflows/kallisto.smk and
+kallisto_trim.smk all match `kallisto index --help` / `kallisto quant --help`.
+
+### bwameth (checked, no change needed)
+`--reference` is the correct, still-current flag for bwameth.py (confirmed
+via `bwameth.py --help`), unlike oarfish/salmon. Not a false positive.
+
+### fgumi (checked, no change needed)
+Container binary is `fgumi` (not `fgbio`). `extract --inputs/--sample
+/--library/--output` all present in `fgumi extract --help`; matches
+workflows/fgumi.smk.
+
+### Tools whose containers do NOT actually contain the expected binary
+(cannot verify CLI flags locally, flagged as a gap, not necessarily a bug):
+- scyphy-1.5.0.sif: no `scyphy` binary in /opt/conda/envs/monsda/bin
+- dorado-1.5.0.sif: no `dorado` binary
+- guppy-1.5.0.sif: no `guppy_basecaller` binary (env only has gettext tools)
+- ciri2-1.5.0.sif: no `CIRI2.pl` binary
+- rustar-1.5.0.sif: no rustar-named binary found (has rust toolchain only)
+These may be intentionally thin/build-in-progress containers (guppy/dorado
+often require separate ONT-licensed installers), or the .sif build failed to
+install the tool - not confirmed which. Not re-tested further this session.
+
+### piscem / alevinfry (checked, no change needed)
+`piscem build` and `piscem map-sc` help match workflows/piscem.smk exactly
+(`-o`, `--decoy-paths`, `-k`, `-t`; `map-sc -t -i -1 -2 -o`, `--geometry` is a
+required user config value, not hardcoded). `alevin-fry generate-permit-list
+/collate/quant` flags (`-i`, `-d`, `-o`, `-t`, `-r`, `-m`, `--use-mtx`) all
+match workflows/alevinfry.smk.
+
+### star / hisat2 (checked, no change needed)
+STAR help (`STAR --help`) confirms `--runThreadN`, `--runMode
+genomeGenerate`, `--genomeDir`, `--genomeFastaFiles`, `--outFileNamePrefix`,
+`--outTmpDir`, `--readFilesCommand`, `--readFilesIn`, `--outReadsUnmapped
+Fastx`, `--outSAMtype BAM SortedByCoordinate`, and every tag in
+`--outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM` used in
+workflows/star.smk. hisat2 `--un-conc-gz`/`-p`/`--summary-file` etc. all
+present in `hisat2 --help`.
+
+### macs2 / macs3 (checked, no change needed)
+`callpeak -t -c --outdir -n -f` all present in both `macs2 callpeak --help`
+and `macs3 callpeak --help`, matching workflows/macs2.smk and macs3.smk.
+
+### umicollapse (checked, no change needed)
+workflows/umicollapse.smk uses two different binaries: `umi_tools` for the
+`whitelist`/`extract` rules (flags `--stdin/--stdout/--read2-in/--read2-out
+/--error-correct-cell/--whitelist/--temp-dir/--log` all confirmed present in
+`umi_tools whitelist --help` / `umi_tools extract --help`), and the Java
+`umicollapse` tool only for the final `bam` dedup rule. Ran `umicollapse bam
+-i tiny.bam -o out.bam --paired` against a real tiny BAM in the container
+(umicollapse 1.1.0-2) and confirmed `-i/-o/--paired` work and produce output.
+
+### umitools (checked, no change needed)
+`umi_tools dedup --stdin/--stdout/--paired/--log/--temp-dir` all present in
+`umi_tools dedup --help`, matching workflows/umitools.smk.
+
+### rustqc (checked, no change needed)
+`rustqc rna --gtf/-g -t -s -p -o -j --skip-dup-check` etc. all present in
+`rustqc rna --help`, matching workflows/rustqc.smk.
+
+### trimgalore / cutadapt / fastp / bbduk (checked, no change needed)
+All hardcoded flags (`--cores/--paired/--gzip/-o`; `--cores -o -p`;
+`--thread --in1/--in2/--out1/--out2`; `t=/in1=/in2=/out1=/out2=`) confirmed
+present in each tool's own `--help`.
+
+### segemehl / segemehl3 (checked, no change needed, naming note)
+Binary is `segemehl.x` in both the segemehl-1.5.0.sif and segemehl3-1.5.0.sif
+containers (segemehl3 does not ship a separate `segemehl3` executable). Not a
+bug: workflows/segemehl3.smk resolves the binary via config (`MAPPERBIN`),
+never hardcodes the name `segemehl3`. `-d/-x/-q/-p/--threads` all present in
+`segemehl.x --help`.
+
+### minimap2 / sra (checked, no change needed)
+`minimap2 -d/-t` and `fasterq-dump -O/-e/-t/--split-files` confirmed present
+in their own `--help`, matching workflows/minimap.smk and sra.smk.
+
+### picard (checked, no change needed)
+`MarkDuplicates --REMOVE_DUPLICATES/--ASSUME_SORT_ORDER/--TMP_DIR/--INPUT
+/--OUTPUT/--METRICS_FILE` all confirmed present in `picard MarkDuplicates
+--help`, matching workflows/picard_dedup.smk.
+
+### piranha (not applicable)
+workflows/piranha.smk never hardcodes Piranha CLI flags itself - the actual
+peak-calling parameters come entirely from user config (`{params.ppara}`).
+`Piranha --help` requires a positional input and errored differently when
+called with only `--help`, but this does not affect MONSDA since no fixed
+flags are baked into the template.
+
+## Summary
+Two real bugs found and fixed this session (both were caused by the
+containers having been rebuilt against newer tool versions with renamed/
+stricter CLI flags):
+1. `oarfish`: `--reference` -> `--genome-fasta` (workflows/oarfish.smk,
+   workflows/oarfish.nf).
+2. `salmon` (salmonalign only): `--writeMappings` now requires an explicit
+   path argument in salmon 2.5.1; changed to `--writeMappings=/dev/stdout`
+   (workflows/salmonalign.smk, workflows/salmonalign.nf).
+
+Every other tool with hardcoded flags in workflows/*.smk (piscem, alevinfry,
+star, hisat2, macs2, macs3, umicollapse, umitools, rustqc, trimgalore,
+cutadapt, fastp, bbduk, kallisto, bwameth, salmon counting modes, segemehl,
+minimap2, sra, picard, fgumi) was checked against the actual container's
+`--help` (or, where `--help` errors before printing usage, a real minimal
+run) and found consistent - no other hardcoded-flag drift detected.
+
+Not checked this session (no hardcoded external-tool CLI flags were found in
+their .smk/.nf, or they are R/perl scripts calling internal MONSDA scripts
+rather than external tool binaries): dexseq_DEU/DTU, edger_DAS/DE/DEU,
+deseq2_DE, drimseq_DTU, diego_DAS, spit_DTU, annotatebed, ucsc, ciri2,
+scyphy, dorado, guppy, rustar, multiqc/multiqc_rustqc, countreads,
+manipulate_genome, bwa/bwa2.
+
+### Tools whose containers do NOT actually contain the expected binary
+(cannot verify CLI flags locally, flagged as a gap, not necessarily a bug):
+- scyphy-1.5.0.sif: no `scyphy` binary in /opt/conda/envs/monsda/bin
+- dorado-1.5.0.sif: no `dorado` binary
+- guppy-1.5.0.sif: no `guppy_basecaller` binary (env only has gettext tools)
+- ciri2-1.5.0.sif: no `CIRI2.pl` binary
+- rustar-1.5.0.sif: no rustar-named binary found (has rust toolchain only)
+These may be intentionally thin/build-in-progress containers (guppy/dorado
+often require separate ONT-licensed installers), or the .sif build failed to
+install the tool - not confirmed which. Not re-tested further this session.
+
diff --git a/tests/tool_audit/audit_tool_flags.py b/tests/tool_audit/audit_tool_flags.py
new file mode 100755
index 00000000..67fd52d7
--- /dev/null
+++ b/tests/tool_audit/audit_tool_flags.py
@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""Audit MONSDA's hardcoded external-tool CLI flags against reality.
+
+Runs each tool named in tool_manifest.yaml inside its apptainer container
+and checks that the flags MONSDA hardcodes in workflows/*.smk and
+workflows/*.nf are still accepted by the tool's own --help (or, for tools
+whose --help exits before printing usage, a minimal real run).
+
+Usage:
+    conda activate apptainer
+    python tests/tool_audit/audit_tool_flags.py [--strict] [--tool NAME ...]
+
+Requires:
+    - apptainer on PATH (e.g. `conda activate apptainer`)
+    - container .sif files under --container-dir (default matches the
+      user's local ~/Work2/Container/MONSDA)
+
+See README.md in this directory for the full manual findings this manifest
+was derived from.
+"""
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    sys.stderr.write(
+        "error: PyYAML is required (pip install pyyaml / conda install pyyaml)\n"
+    )
+    sys.exit(2)
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_MANIFEST = HERE / "tool_manifest.yaml"
+DEFAULT_CONTAINER_DIR = Path.home() / "Work2" / "Container" / "MONSDA"
+DEFAULT_CONTAINER_SUFFIX = "-1.5.0.sif"
+DEFAULT_TIMEOUT = 60
+
+STATUS_PASS = "PASS"
+STATUS_DRIFT = "DRIFT"
+STATUS_GAP = "GAP"
+STATUS_SKIP = "SKIP"
+
+
+class Result:
+    def __init__(self, tool, invocation, status, detail):
+        self.tool = tool
+        self.invocation = invocation
+        self.status = status
+        self.detail = detail
+
+    def as_dict(self):
+        return {
+            "tool": self.tool,
+            "invocation": self.invocation,
+            "status": self.status,
+            "detail": self.detail,
+        }
+
+
+def load_manifest(path):
+    with open(path) as fh:
+        data = yaml.safe_load(fh)
+    return data.get("tools", {})
+
+
+def apptainer_available():
+    return shutil.which("apptainer") is not None
+
+
+def container_path(container_dir, container_name, suffix):
+    return Path(container_dir) / f"{container_name}{suffix}"
+
+
+def run_apptainer(sif, binary, args, timeout, extra_binds=None):
+    cmd = ["apptainer", "exec"]
+    for b in extra_binds or []:
+        cmd += ["--bind", b]
+    cmd += [str(sif), binary, *args]
+    try:
+        proc = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=timeout
+        )
+        return proc.returncode, proc.stdout, proc.stderr, None
+    except subprocess.TimeoutExpired:
+        return None, "", "", f"timed out after {timeout}s"
+    except FileNotFoundError as e:
+        return None, "", "", str(e)
+
+
+def binary_missing(returncode, stderr):
+    if returncode == 127:
+        return True
+    low = stderr.lower()
+    return "executable file not found" in low or "command not found" in low
+
+
+def check_help_invocation(tool, container_name, binary, sif, inv, timeout):
+    name = inv.get("name", "help")
+    args = inv.get("args", ["--help"])
+    expect_exit = inv.get("expect_exit", [0])
+    expected_flags = inv.get("expected_flags", [])
+    expected_text = inv.get("expected_text", [])
+    expect_value_required = inv.get("expect_value_required", False)
+
+    rc, out, err, launch_err = run_apptainer(sif, binary, args, timeout)
+    if launch_err is not None:
+        return Result(tool, name, STATUS_GAP, f"could not launch: {launch_err}")
+    if binary_missing(rc, err):
+        return Result(
+            tool, name, STATUS_GAP, f"binary '{binary}' not found in container"
+        )
+
+    combined = out + "\n" + err
+    if rc not in expect_exit:
+        return Result(
+            tool,
+            name,
+            STATUS_DRIFT,
+            f"exit code {rc} not in expected {expect_exit}; output head: "
+            f"{combined.strip()[:200]!r}",
+        )
+
+    missing = [f for f in expected_flags if f not in combined]
+    missing += [t for t in expected_text if t not in combined]
+    if missing:
+        return Result(
+            tool, name, STATUS_DRIFT, f"flags/text missing from help output: {missing}"
+        )
+
+    if expect_value_required:
+        # Regression check: the flag (first entry in expected_flags) must
+        # error out if invoked bare/without a value, not silently accept it.
+        flag = expected_flags[0]
+        rc2, out2, err2, launch_err2 = run_apptainer(
+            sif, binary, args[:-1] + [flag] if args and args[-1] == "--help" else [flag],
+            timeout,
+        )
+        # Fall back: just invoke the subcommand (without --help) plus the bare flag
+        if launch_err2 is None and not binary_missing(rc2, err2):
+            combined2 = (out2 + err2).lower()
+            if rc2 == 0 or "value is required" not in combined2 and "requires a value" not in combined2 and "requires an argument" not in combined2:
+                return Result(
+                    tool,
+                    name,
+                    STATUS_DRIFT,
+                    f"expected '{flag}' to require an explicit value again "
+                    "(regression check for old bare-flag behaviour), but "
+                    f"invocation did not error as expected (exit={rc2})",
+                )
+
+    return Result(tool, name, STATUS_PASS, "ok")
+
+
+def check_minimal_run_invocation(tool, container_name, binary, sif, inv, timeout, fixtures_dir):
+    name = inv.get("name", "minimal_run")
+    fixture = inv.get("fixture")
+    expect_exit = inv.get("expect_exit", [0])
+    args_template = inv.get("args_template", [])
+    expect_output_exists = inv.get("expect_output_exists")
+
+    fixture_path = fixtures_dir / fixture if fixture else None
+    if fixture_path is not None and not fixture_path.exists():
+        return Result(
+            tool, name, STATUS_GAP, f"fixture missing: {fixture_path}"
+        )
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        args = [
+            a.format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir)
+            for a in args_template
+        ]
+        binds = [f"{tmpdir}:{tmpdir}"]
+        if fixture_path is not None:
+            binds.append(f"{fixture_path.parent}:{fixture_path.parent}")
+
+        rc, out, err, launch_err = run_apptainer(sif, binary, args, timeout, extra_binds=binds)
+        if launch_err is not None:
+            return Result(tool, name, STATUS_GAP, f"could not launch: {launch_err}")
+        if binary_missing(rc, err):
+            return Result(
+                tool, name, STATUS_GAP, f"binary '{binary}' not found in container"
+            )
+        if rc not in expect_exit:
+            return Result(
+                tool,
+                name,
+                STATUS_DRIFT,
+                f"exit code {rc} not in expected {expect_exit}; stderr head: "
+                f"{err.strip()[:200]!r}",
+            )
+        if expect_output_exists:
+            out_path = Path(expect_output_exists.format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir))
+            if not out_path.exists() or out_path.stat().st_size == 0:
+                return Result(
+                    tool, name, STATUS_DRIFT, f"expected output not created: {out_path}"
+                )
+
+    return Result(tool, name, STATUS_PASS, "ok")
+
+
+def audit_tool(tool, spec, container_dir, suffix, timeout, fixtures_dir):
+    if spec.get("na"):
+        return [Result(tool, "n/a", STATUS_SKIP, spec.get("na_reason", "no hardcoded flags"))]
+
+    container_name = spec.get("container", tool)
+    binary = spec.get("binary", tool)
+    sif = container_path(container_dir, container_name, suffix)
+
+    known_gap = spec.get("known_gap", False)
+
+    if not sif.exists():
+        detail = f"container file missing: {sif}"
+        return [Result(tool, "n/a", STATUS_GAP, detail)]
+
+    results = []
+    invocations = spec.get("invocations", [])
+    if not invocations and known_gap:
+        # Probe the binary directly to confirm/refresh the known gap.
+        rc, out, err, launch_err = run_apptainer(sif, binary, ["--help"], timeout)
+        if launch_err is not None or binary_missing(rc, err):
+            results.append(
+                Result(tool, "presence", STATUS_GAP, spec.get("gap_reason", "known gap"))
+            )
+        else:
+            results.append(
+                Result(
+                    tool,
+                    "presence",
+                    STATUS_DRIFT,
+                    "binary now FOUND in container but manifest still marks "
+                    "known_gap: true and has no invocations to check - "
+                    "update tool_manifest.yaml",
+                )
+            )
+        return results
+
+    for inv in invocations:
+        if inv.get("skip"):
+            results.append(
+                Result(
+                    tool,
+                    inv.get("name", "skip"),
+                    STATUS_SKIP,
+                    inv.get("skip_reason", "marked skip in manifest"),
+                )
+            )
+            continue
+        mode = inv.get("mode", "help")
+        if mode == "minimal_run":
+            results.append(
+                check_minimal_run_invocation(
+                    tool, container_name, binary, sif, inv, timeout, fixtures_dir
+                )
+            )
+        else:
+            results.append(
+                check_help_invocation(tool, container_name, binary, sif, inv, timeout)
+            )
+
+    # Reclassify GAP results for tools already known to be gap-y, unless
+    # they newly started passing (handled above) or the gap moved (still a
+    # GAP either way, just flagged non-fatal below in the summary/exit code
+    # logic via `known_gap`).
+    return results
+
+
+def print_table(all_results, manifest):
+    widths = (14, 22, 8)
+    header = f"{'TOOL':<{widths[0]}} {'INVOCATION':<{widths[1]}} {'STATUS':<{widths[2]}} DETAIL"
+    print(header)
+    print("-" * len(header))
+    for r in all_results:
+        print(f"{r.tool:<{widths[0]}} {r.invocation:<{widths[1]}} {r.status:<{widths[2]}} {r.detail}")
+
+
+def summarize(all_results, manifest, strict):
+    counts = {STATUS_PASS: 0, STATUS_DRIFT: 0, STATUS_GAP: 0, STATUS_SKIP: 0}
+    fatal = []
+    for r in all_results:
+        counts[r.status] = counts.get(r.status, 0) + 1
+        if r.status == STATUS_DRIFT:
+            fatal.append(r)
+        elif r.status == STATUS_GAP:
+            known = manifest.get(r.tool, {}).get("known_gap", False)
+            if not known:
+                fatal.append(r)
+            elif strict:
+                fatal.append(r)
+
+    print()
+    print(
+        f"Summary: {counts[STATUS_PASS]} passed, {counts[STATUS_DRIFT]} drifted, "
+        f"{counts[STATUS_GAP]} gaps, {counts[STATUS_SKIP]} skipped"
+    )
+    if fatal:
+        print(f"FAILED: {len(fatal)} finding(s) require attention:")
+        for r in fatal:
+            print(f"  - [{r.status}] {r.tool} / {r.invocation}: {r.detail}")
+    return fatal
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--manifest", default=str(DEFAULT_MANIFEST))
+    ap.add_argument("--container-dir", default=str(DEFAULT_CONTAINER_DIR))
+    ap.add_argument("--container-suffix", default=DEFAULT_CONTAINER_SUFFIX)
+    ap.add_argument("--tool", action="append", dest="tools", default=None,
+                     help="limit to specific tool name(s); repeatable")
+    ap.add_argument("--strict", action="store_true",
+                     help="treat known gaps as failures too")
+    ap.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT)
+    ap.add_argument("--json-out", default=None)
+    args = ap.parse_args(argv)
+
+    if not apptainer_available():
+        sys.stderr.write(
+            "error: 'apptainer' not found on PATH. Activate the apptainer "
+            "conda env first, e.g.:\n"
+            "  source ~/anaconda3/etc/profile.d/conda.sh && conda activate apptainer\n"
+        )
+        return 3
+
+    manifest_path = Path(args.manifest)
+    if not manifest_path.exists():
+        sys.stderr.write(f"error: manifest not found: {manifest_path}\n")
+        return 3
+    manifest = load_manifest(manifest_path)
+
+    container_dir = Path(args.container_dir).expanduser()
+    if not container_dir.exists():
+        sys.stderr.write(
+            f"error: container dir not found: {container_dir} "
+            "(pass --container-dir to override)\n"
+        )
+        return 3
+
+    fixtures_dir = HERE / "fixtures"
+
+    tool_names = args.tools or sorted(manifest.keys())
+    unknown = [t for t in tool_names if t not in manifest]
+    if unknown:
+        sys.stderr.write(f"error: unknown tool(s) in --tool: {unknown}\n")
+        return 3
+
+    all_results = []
+    for tool in tool_names:
+        spec = manifest[tool]
+        all_results.extend(
+            audit_tool(tool, spec, container_dir, args.container_suffix, args.timeout, fixtures_dir)
+        )
+
+    print_table(all_results, manifest)
+    fatal = summarize(all_results, manifest, args.strict)
+
+    if args.json_out:
+        with open(args.json_out, "w") as fh:
+            json.dump([r.as_dict() for r in all_results], fh, indent=2)
+
+    return 1 if fatal else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/tool_audit/bwameth_help.txt b/tests/tool_audit/bwameth_help.txt
new file mode 100644
index 00000000..9764469a
--- /dev/null
+++ b/tests/tool_audit/bwameth_help.txt
@@ -0,0 +1,62 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+/opt/conda/envs/monsda/bin/bwameth.py:317: SyntaxWarning: "\d" is an invalid escape sequence. Such sequences will not work in the future. Did you mean "\\d"? A raw string is also an option.
+  def longest_match(self, patt=re.compile("\d+M")):
+usage: 
+map bisulfite converted reads to an insilico converted genome using bwa mem OR bwa mem2.
+A command to this program like:
+
+    python bwameth.py --reference ref.fa A.fq B.fq
+
+Gets converted to:
+
+    bwa mem -pCMR ref.fa.bwameth.c2t '<python bwameth.py c2t A.fq B.fq'
+    OR
+    bwa-mem2 mem -pCMR ref.fa.bwameth.c2t '<python bwameth.py c2t A.fq B.fq'
+
+So that A.fq has C's converted to T's and B.fq has G's converted to A's
+and both are streamed directly to the aligner without a temporary file
+producing standard SAM output. 
+
+Index from BWA-MEM or BWA-MEM2 is auto detected and the corresponding aligner is chosen.
+
+Indexing:
+bwa-meth supports indexes from BWA-MEM and BWA-MEM2.
+
+    bwameth.py index $REF #For BWA-MEM (default)
+    OR
+    bwameth.py index-mem2 $REF #For BWA-MEM2
+
+       [-h] --reference REFERENCE [-t THREADS] [--read-group READ_GROUP]
+       [--set-as-failed {f,r}] [-p] [--version] [--do-not-penalize-chimeras]
+       fastqs [fastqs ...]
+
+positional arguments:
+  fastqs                bs-seq fastqs to align. Runmultiple sets separated by
+                        commas, e.g. ... a_R1.fastq,b_R1.fastq
+                        a_R2.fastq,b_R2.fastq note that the order must be
+                        maintained.
+
+options:
+  -h, --help            show this help message and exit
+  --reference REFERENCE
+                        reference fasta
+  -t, --threads THREADS
+  --read-group READ_GROUP
+                        read-group to add to bam in same format as to bwa:
+                        '@RG\tID:foo\tSM:bar'
+  --set-as-failed {f,r}
+                        flag alignments to this strand as not passing QC
+                        (0x200). Targetted BS-Seq libraries are often to a
+                        single strand, so we can flag them as QC failures.
+                        Note f == OT, r == OB. Likely, this will be 'f' as we
+                        will expect reads to align to the original-bottom (OB)
+                        strand and will flag as failed those aligning to the
+                        forward, or original top (OT).
+  -p, --interleaved     fastq files have 4 lines of read1 followed by 4 lines
+                        of read2 (e.g. seqtk mergepe output)
+  --version             show program's version number and exit
+  --do-not-penalize-chimeras
+                        do not use the heuristic that if the longest match is
+                        not 44% of the sequence length, we mark it as failed
+                        QC and un-pair it, and set all members of pair to
+                        unmapped
diff --git a/tests/tool_audit/extract_workflow_commands.py b/tests/tool_audit/extract_workflow_commands.py
new file mode 100755
index 00000000..25e06836
--- /dev/null
+++ b/tests/tool_audit/extract_workflow_commands.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Dump shell/script blocks from workflows/*.smk and workflows/*.nf.
+
+Reusable version of the throwaway extractor used to build
+smk_shell_commands.txt / nf_script_commands.txt during the manual CLI-flag
+audit. Regenerate these dumps with --refresh whenever a workflow's shell
+commands change, then use them as a reference while updating
+tool_manifest.yaml by hand (the dumps themselves are not consumed by
+audit_tool_flags.py).
+
+Usage:
+    python tests/tool_audit/extract_workflow_commands.py --refresh
+    python tests/tool_audit/extract_workflow_commands.py --check-manifest
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent.parent
+WORKFLOWS_DIR = REPO_ROOT / "workflows"
+
+SMK_SHELL_RE_DOUBLE = re.compile(r'shell:\s*"((?:[^"\\]|\\.)*)"')
+SMK_SHELL_RE_TRIPLE = re.compile(r"shell:\s*'''(.*?)'''", re.S)
+NF_SCRIPT_RE = re.compile(r'"""(.*?)"""', re.S)
+
+
+def iter_shell_blocks(smk_path):
+    text = smk_path.read_text()
+    for m in SMK_SHELL_RE_DOUBLE.finditer(text):
+        yield m.group(1)
+    for m in SMK_SHELL_RE_TRIPLE.finditer(text):
+        yield m.group(1)
+
+
+def iter_script_blocks(nf_path):
+    text = nf_path.read_text()
+    for m in NF_SCRIPT_RE.finditer(text):
+        yield m.group(1)
+
+
+def dump_smk(out_path):
+    with open(out_path, "w") as out:
+        for f in sorted(WORKFLOWS_DIR.glob("*.smk")):
+            for block in iter_shell_blocks(f):
+                out.write(f"### {f.name}\n{block}\n\n")
+
+
+def dump_nf(out_path):
+    with open(out_path, "w") as out:
+        for f in sorted(WORKFLOWS_DIR.glob("*.nf")):
+            for block in iter_script_blocks(f):
+                out.write(f"### {f.name}\n{block}\n\n")
+
+
+def check_manifest_coverage(manifest_path, smk_dump, nf_dump):
+    """Sanity check: every source_ref in the manifest should still be found
+    as a filename header in the corresponding dump, catching the extractor
+    silently failing to parse new syntax."""
+    import yaml
+
+    with open(manifest_path) as fh:
+        manifest = yaml.safe_load(fh).get("tools", {})
+
+    smk_text = smk_dump.read_text() if smk_dump.exists() else ""
+    nf_text = nf_dump.read_text() if nf_dump.exists() else ""
+
+    problems = []
+    for tool, spec in manifest.items():
+        for inv in spec.get("invocations", []):
+            for ref in inv.get("source_refs", []):
+                name = Path(ref).name
+                if ref.endswith(".smk") and f"### {name}" not in smk_text:
+                    problems.append(f"{tool}: {ref} not found in {smk_dump.name}")
+                elif ref.endswith(".nf") and f"### {name}" not in nf_text:
+                    problems.append(f"{tool}: {ref} not found in {nf_dump.name}")
+    return problems
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--refresh", action="store_true",
+                     help="regenerate smk_shell_commands.txt / nf_script_commands.txt")
+    ap.add_argument("--check-manifest", action="store_true",
+                     help="check tool_manifest.yaml source_refs are still covered by the dumps")
+    args = ap.parse_args()
+
+    smk_dump = HERE / "smk_shell_commands.txt"
+    nf_dump = HERE / "nf_script_commands.txt"
+
+    if args.refresh:
+        dump_smk(smk_dump)
+        dump_nf(nf_dump)
+        print(f"wrote {smk_dump}")
+        print(f"wrote {nf_dump}")
+
+    if args.check_manifest:
+        problems = check_manifest_coverage(HERE / "tool_manifest.yaml", smk_dump, nf_dump)
+        if problems:
+            print("Manifest coverage problems:")
+            for p in problems:
+                print(f"  - {p}")
+            return 1
+        print("Manifest source_refs all covered by current dumps.")
+
+    if not args.refresh and not args.check_manifest:
+        ap.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/tool_audit/fixtures/README.md b/tests/tool_audit/fixtures/README.md
new file mode 100644
index 00000000..8431f935
--- /dev/null
+++ b/tests/tool_audit/fixtures/README.md
@@ -0,0 +1,25 @@
+# Fixtures for tests/tool_audit/audit_tool_flags.py
+
+## tiny.bam
+
+Minimal coordinate-sorted BAM (3 reads, 2 alignment positions on a fake
+`chr1`, one duplicated position) used for the `umicollapse` `minimal_run`
+check, since `umicollapse --help` exits non-zero with "Missing input
+file!" before printing usage and cannot be flag-checked via help text.
+
+Regenerate with (inside the `apptainer` conda env):
+
+    cat > tiny.sam << 'EOF'
+    @HD	VN:1.6	SO:coordinate
+    @SQ	SN:chr1	LN:1000
+    r1_ACGTACGT	0	chr1	1	60	4M	*	0	0	ACGT	IIII
+    r2_ACGTACGA	0	chr1	1	60	4M	*	0	0	ACGT	IIII
+    r3_TTTTACGT	0	chr1	5	60	4M	*	0	0	TTTT	IIII
+    EOF
+    apptainer exec ~/Work2/Container/MONSDA/umicollapse-1.5.0.sif \
+        samtools view -b -o tiny.bam tiny.sam
+
+Verified this dedups to 2 reads via:
+
+    apptainer exec --bind $PWD:$PWD ~/Work2/Container/MONSDA/umicollapse-1.5.0.sif \
+        umicollapse bam -i $PWD/tiny.bam -o $PWD/out.bam --paired
diff --git a/tests/tool_audit/fixtures/tiny.bam b/tests/tool_audit/fixtures/tiny.bam
new file mode 100644
index 0000000000000000000000000000000000000000..8e5e5f4e68ddca937d9bdab97cf1fcde1235dadb
GIT binary patch
literal 261
zcmb2|=3rp}f&Xj_PR>jW6B&w&zND^6N=PX9Q1FoF^Jb$f#*cZvZTC8NUf=8F8E+lW
zr$romPk6p<_By9w^yCYpmVtr6gCdTC=U+-TYWbbfJ$e4T<};oT&KnN4Nk|r1{XTG1
z<djkHY0;9&A|;<iy^KC<eVrs!tjM!~OV4e=+cge6n;IXo8Z$F96rC0{n+$Y_JerHb
z7>tu0804h=72OohG9CH9kU=FbMdJO7H*!pec=#OlO=xEmm?60MGRLyZg57>%HCDZk
fof{bP(%swJ+S=F{R(*0aS%<|~X$EGHx4{4aQYKqe

literal 0
HcmV?d00001

diff --git a/tests/tool_audit/help/af_collate.txt b/tests/tool_audit/help/af_collate.txt
new file mode 100644
index 00000000..e5cab646
--- /dev/null
+++ b/tests/tool_audit/help/af_collate.txt
@@ -0,0 +1,15 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Collate a RAD file by corrected cell barcode
+
+Usage: alevin-fry collate [OPTIONS] --input-dir <INPUTDIR> --rad-dir <RADFILE>
+
+Options:
+  -i, --input-dir <INPUTDIR>  input directory made by generate-permit-list
+  -r, --rad-dir <RADFILE>     the directory containing the RAD file to be collated
+  -t, --threads <THREADS>     number of threads to use for processing (minimum: 2; lower values use
+                              2) [default: 16]
+  -c, --compress              compress the output collated RAD file
+      --memory-limit <SIZE>   collation buffer budget, excluding indexes and page cache (for example
+                              2GiB or 4GB; default: 2GiB)
+  -h, --help                  Print help
+  -V, --version               Print version
diff --git a/tests/tool_audit/help/af_genpermit.txt b/tests/tool_audit/help/af_genpermit.txt
new file mode 100644
index 00000000..5881be62
--- /dev/null
+++ b/tests/tool_audit/help/af_genpermit.txt
@@ -0,0 +1,60 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Generate a permit list of barcodes from a RAD file
+
+Usage: alevin-fry generate-permit-list [OPTIONS] --input <INPUT> --expected-ori <EXPECTEDORI> --output-dir <OUTPUTDIR> <--knee-distance|--expect-cells <EXPECTCELLS>|--force-cells <FORCECELLS>|--valid-bc <VALIDBC>|--unfiltered-pl <UNFILTEREDPL>>
+
+Options:
+  -i, --input <INPUT>
+          input directory containing the map.rad RAD file
+  -d, --expected-ori <EXPECTEDORI>
+          the expected orientation of alignments [possible values: fw, rc, both, either]
+  -o, --output-dir <OUTPUTDIR>
+          output directory
+  -k, --knee-distance
+          attempt to determine the number of barcodes to keep using the knee distance method.
+  -t, --threads <THREADS>
+          number of threads to use for the first phase of permit-list generation (minimum: 2; lower
+          values use 2) [default: 8]
+  -e, --expect-cells <EXPECTCELLS>
+          defines the expected number of cells to use in determining the (read, not UMI) based
+          cutoff
+  -f, --force-cells <FORCECELLS>
+          select the top-k most-frequent barcodes, based on read count, as valid (true)
+  -b, --valid-bc <VALIDBC>
+          uses true barcode collected from a provided file
+  -u, --unfiltered-pl <UNFILTEREDPL>
+          uses an unfiltered external permit list
+  -m, --min-reads <MINREADS>
+          minimum read count threshold; only used with --unfiltered-pl [default: 10]
+      --sample-bc-list <SAMPLELIST>
+          file containing known sample/library barcodes (one per line); triggers multi-barcode mode
+      --sample-names <SAMPLENAMES>
+          file mapping sample barcodes to human-readable names (TSV: barcode\tname)
+      --sample-bc-correction <SCMODE>
+          sample-barcode correction policy [possible values: exact, unique, frequency]
+      --cell-bc-correction <STRATEGY>
+          cell-barcode collision policy: `unique` accepts one canonical target; `frequency` uses
+          frozen exact counts and a confidence threshold [default: unique] [possible values: unique,
+          frequency]
+      --cell-bc-neighborhood <NEIGHBORHOOD>
+          cell-barcode neighbourhood; edit-1 is a compatibility alias for substitution-or-shift-1
+          [possible values: hamming-1, substitution-or-shift-1, edit-1]
+      --sample-bc-neighborhood <NEIGHBORHOOD>
+          sample-barcode neighbourhood for non-exact correction [default: hamming-1] [possible
+          values: hamming-1, substitution-or-shift-1, edit-1]
+      --cell-bc-confidence <CONFIDENCE>
+          Frequency confidence as a decimal or exact fraction [default: 0.975]
+      --sample-bc-confidence <CONFIDENCE>
+          sample-Frequency confidence as a decimal or exact fraction [default: 0.975]
+      --memory-limit <MEMORY>
+          memory available to deferred GPL correction buffers [default: 512MiB]
+      --tmp-dir <TMPDIR>
+          directory for temporary GPL correction spools (default: output directory)
+      --sample-bc-ori <SBCORI>
+          orientation of sample barcodes in the whitelist relative to the read (forward = whitelist
+          matches read as-is; reverse = reverse-complement the whitelist before lookup, e.g. 10x
+          Flex v2) [default: forward] [possible values: forward, reverse]
+  -h, --help
+          Print help
+  -V, --version
+          Print version
diff --git a/tests/tool_audit/help/af_quant.txt b/tests/tool_audit/help/af_quant.txt
new file mode 100644
index 00000000..3f48706f
--- /dev/null
+++ b/tests/tool_audit/help/af_quant.txt
@@ -0,0 +1,32 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Quantify expression from a collated RAD file
+
+Usage: alevin-fry quant [OPTIONS] --input-dir <INPUTDIR> --tg-map <TGMAP> --output-dir <OUTPUTDIR> --resolution <RESOLUTION>
+
+Options:
+  -i, --input-dir <INPUTDIR>            input directory containing collated RAD file
+  -m, --tg-map <TGMAP>                  transcript to gene map
+  -o, --output-dir <OUTPUTDIR>          output directory where quantification results will be
+                                        written
+  -t, --threads <THREADS>               number of threads to use for processing (minimum: 2; lower
+                                        values use 2) [default: 16]
+  -d, --dump-eqclasses                  flag for dumping equivalence classes
+  -b, --num-bootstraps <NUMBOOTSTRAPS>  number of bootstraps to use [default: 0]
+      --init-uniform                    flag for uniform sampling
+      --summary-stat                    flag for storing only summary statistics
+      --use-mtx                         flag for writing output matrix in matrix market format
+                                        (default, kept for compatibility)
+      --quant-subset <SFILE>            file containing list of barcodes to quantify, those not in
+                                        this list will be ignored
+  -r, --resolution <RESOLUTION>         the resolution strategy by which molecules will be counted
+                                        [possible values: trivial, cr-like, cr-like-em,
+                                        parsimony-em, parsimony, parsimony-gene-em, parsimony-gene]
+      --small-thresh <SMALLTHRESH>      cells with fewer than this many reads are resolved by a fast
+                                        path that applies cr-like (winner-take-all) semantics
+                                        regardless of --resolution; pass 0 to resolve every cell
+                                        with the requested strategy [default: 100]
+      --multi-sample-output <MSOUTPUT>  output mode for multi-sample data: separate per-sample
+                                        matrices, one combined matrix, or both [default: separate]
+                                        [possible values: separate, combined, both]
+  -h, --help                            Print help
+  -V, --version                         Print version
diff --git a/tests/tool_audit/help/alevinfry.txt b/tests/tool_audit/help/alevinfry.txt
new file mode 100644
index 00000000..c9e76302
--- /dev/null
+++ b/tests/tool_audit/help/alevinfry.txt
@@ -0,0 +1,18 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Process RAD files from the command line
+
+Usage: alevin-fry <COMMAND>
+
+Commands:
+  generate-permit-list  Generate a permit list of barcodes from a RAD file
+  collate               Collate a RAD file by corrected cell barcode
+  quant                 Quantify expression from a collated RAD file
+  infer                 Perform inference on equivalence class count data
+  convert               Convert a BAM file to a RAD file
+  view                  View a RAD file
+  atac                  subcommand for processing scATAC-seq RAD files
+  help                  Print this message or the help of the given subcommand(s)
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
diff --git a/tests/tool_audit/help/bbduk_help.txt b/tests/tool_audit/help/bbduk_help.txt
new file mode 100644
index 00000000..ea865073
--- /dev/null
+++ b/tests/tool_audit/help/bbduk_help.txt
@@ -0,0 +1,320 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+Written by Brian Bushnell
+Last modified July 28, 2022
+
+Description:  Compares reads to the kmers in a reference dataset, optionally 
+allowing an edit distance. Splits the reads into two outputs - those that 
+match the reference, and those that don't. Can also trim (remove) the matching 
+parts of the reads rather than binning the reads.
+Please read bbmap/docs/guides/BBDukGuide.txt for more information.
+
+Usage:  bbduk.sh in=<input file> out=<output file> ref=<contaminant files>
+
+Input may be stdin or a fasta or fastq file, compressed or uncompressed.
+If you pipe via stdin/stdout, please include the file type; e.g. for gzipped 
+fasta input, set in=stdin.fa.gz
+
+Input parameters:
+in=<file>           Main input. in=stdin.fq will pipe from stdin.
+in2=<file>          Input for 2nd read of pairs in a different file.
+ref=<file,file>     Comma-delimited list of reference files.
+                    In addition to filenames, you may also use the keywords:
+                    adapters, artifacts, phix, lambda, pjet, mtst, kapa
+literal=<seq,seq>   Comma-delimited list of literal reference sequences.
+touppercase=f       (tuc) Change all bases upper-case.
+interleaved=auto    (int) t/f overrides interleaved autodetection.
+qin=auto            Input quality offset: 33 (Sanger), 64, or auto.
+reads=-1            If positive, quit after processing X reads or pairs.
+copyundefined=f     (cu) Process non-AGCT IUPAC reference bases by making all
+                    possible unambiguous copies.  Intended for short motifs
+                    or adapter barcodes, as time/memory use is exponential.
+samplerate=1        Set lower to only process a fraction of input reads.
+samref=<file>       Optional reference fasta for processing sam files.
+
+Output parameters:
+out=<file>          (outnonmatch) Write reads here that do not contain 
+                    kmers matching the database.  'out=stdout.fq' will pipe 
+                    to standard out.
+out2=<file>         (outnonmatch2) Use this to write 2nd read of pairs to a 
+                    different file.
+outm=<file>         (outmatch) Write reads here that fail filters.  In default
+                    kfilter mode, this means any read with a matching kmer.
+                    In any mode, it also includes reads that fail filters such
+                    as minlength, mingc, maxgc, entropy, etc.  In other words,
+                    it includes all reads that do not go to 'out'.
+outm2=<file>        (outmatch2) Use this to write 2nd read of pairs to a 
+                    different file.
+outs=<file>         (outsingle) Use this to write singleton reads whose mate 
+                    was trimmed shorter than minlen.
+stats=<file>        Write statistics about which contamininants were detected.
+refstats=<file>     Write statistics on a per-reference-file basis.
+rpkm=<file>         Write RPKM for each reference sequence (for RNA-seq).
+dump=<file>         Dump kmer tables to a file, in fasta format.
+duk=<file>          Write statistics in duk's format. *DEPRECATED*
+nzo=t               Only write statistics about ref sequences with nonzero hits.
+overwrite=t         (ow) Grant permission to overwrite files.
+showspeed=t         (ss) 'f' suppresses display of processing speed.
+ziplevel=2          (zl) Compression level; 1 (min) through 9 (max).
+fastawrap=70        Length of lines in fasta output.
+qout=auto           Output quality offset: 33 (Sanger), 64, or auto.
+statscolumns=3      (cols) Number of columns for stats output, 3 or 5.
+                    5 includes base counts.
+rename=f            Rename reads to indicate which sequences they matched.
+refnames=f          Use names of reference files rather than scaffold IDs.
+trd=f               Truncate read and ref names at the first whitespace.
+ordered=f           Set to true to output reads in same order as input.
+maxbasesout=-1      If positive, quit after writing approximately this many
+                    bases to out (outu/outnonmatch).
+maxbasesoutm=-1     If positive, quit after writing approximately this many
+                    bases to outm (outmatch).
+json=f              Print to screen in json format.
+
+Histogram output parameters:
+bhist=<file>        Base composition histogram by position.
+qhist=<file>        Quality histogram by position.
+qchist=<file>       Count of bases with each quality value.
+aqhist=<file>       Histogram of average read quality.
+bqhist=<file>       Quality histogram designed for box plots.
+lhist=<file>        Read length histogram.
+phist=<file>        Polymer length histogram.
+gchist=<file>       Read GC content histogram.
+enthist=<file>      Read entropy histogram.
+ihist=<file>        Insert size histogram, for paired reads in mapped sam.
+gcbins=100          Number gchist bins.  Set to 'auto' to use read length.
+maxhistlen=6000     Set an upper bound for histogram lengths; higher uses 
+                    more memory.  The default is 6000 for some histograms
+                    and 80000 for others.
+
+Histograms for mapped sam/bam files only:
+histbefore=t        Calculate histograms from reads before processing.
+ehist=<file>        Errors-per-read histogram.
+qahist=<file>       Quality accuracy histogram of error rates versus quality 
+                    score.
+indelhist=<file>    Indel length histogram.
+mhist=<file>        Histogram of match, sub, del, and ins rates by position.
+idhist=<file>       Histogram of read count versus percent identity.
+idbins=100          Number idhist bins.  Set to 'auto' to use read length.
+varfile=<file>      Ignore substitution errors listed in this file when 
+                    calculating error rates.  Can be generated with
+                    CallVariants.
+vcf=<file>          Ignore substitution errors listed in this VCF file 
+                    when calculating error rates.
+ignorevcfindels=t   Also ignore indels listed in the VCF.
+
+Processing parameters:
+k=27                Kmer length used for finding contaminants.  Contaminants 
+                    shorter than k will not be found.  k must be at least 1.
+rcomp=t             Look for reverse-complements of kmers in addition to 
+                    forward kmers.
+maskmiddle=t        (mm) Treat the middle base of a kmer as a wildcard, to 
+                    increase sensitivity in the presence of errors.
+minkmerhits=1       (mkh) Reads need at least this many matching kmers 
+                    to be considered as matching the reference.
+minkmerfraction=0.0 (mkf) A reads needs at least this fraction of its total
+                    kmers to hit a ref, in order to be considered a match.
+                    If this and minkmerhits are set, the greater is used.
+mincovfraction=0.0  (mcf) A reads needs at least this fraction of its total
+                    bases to be covered by ref kmers to be considered a match.
+                    If specified, mcf overrides mkh and mkf.
+hammingdistance=0   (hdist) Maximum Hamming distance for ref kmers (subs only).
+                    Memory use is proportional to (3*K)^hdist.
+qhdist=0            Hamming distance for query kmers; impacts speed, not memory.
+editdistance=0      (edist) Maximum edit distance from ref kmers (subs 
+                    and indels).  Memory use is proportional to (8*K)^edist.
+hammingdistance2=0  (hdist2) Sets hdist for short kmers, when using mink.
+qhdist2=0           Sets qhdist for short kmers, when using mink.
+editdistance2=0     (edist2) Sets edist for short kmers, when using mink.
+forbidn=f           (fn) Forbids matching of read kmers containing N.
+                    By default, these will match a reference 'A' if 
+                    hdist>0 or edist>0, to increase sensitivity.
+removeifeitherbad=t (rieb) Paired reads get sent to 'outmatch' if either is 
+                    match (or either is trimmed shorter than minlen).  
+                    Set to false to require both.
+trimfailures=f      Instead of discarding failed reads, trim them to 1bp.
+                    This makes the statistics a bit odd.
+findbestmatch=f     (fbm) If multiple matches, associate read with sequence 
+                    sharing most kmers.  Reduces speed.
+skipr1=f            Don't do kmer-based operations on read 1.
+skipr2=f            Don't do kmer-based operations on read 2.
+ecco=f              For overlapping paired reads only.  Performs error-
+                    correction with BBMerge prior to kmer operations.
+recalibrate=f       (recal) Recalibrate quality scores.  Requires calibration
+                    matrices generated by CalcTrueQuality.
+sam=<file,file>     If recalibration is desired, and matrices have not already
+                    been generated, BBDuk will create them from the sam file.
+amino=f             Run in amino acid mode.  Some features have not been
+                    tested, but kmer-matching works fine.  Maximum k is 12.
+
+Speed and Memory parameters:
+threads=auto        (t) Set number of threads to use; default is number of 
+                    logical processors.
+prealloc=f          Preallocate memory in table.  Allows faster table loading 
+                    and more efficient memory usage, for a large reference.
+monitor=f           Kill this process if it crashes.  monitor=600,0.01 would 
+                    kill after 600 seconds under 1% usage.
+minrskip=1          (mns) Force minimal skip interval when indexing reference 
+                    kmers.  1 means use all, 2 means use every other kmer, etc.
+maxrskip=1          (mxs) Restrict maximal skip interval when indexing 
+                    reference kmers. Normally all are used for scaffolds<100kb, 
+                    but with longer scaffolds, up to maxrskip-1 are skipped.
+rskip=              Set both minrskip and maxrskip to the same value.
+                    If not set, rskip will vary based on sequence length.
+qskip=1             Skip query kmers to increase speed.  1 means use all.
+speed=0             Ignore this fraction of kmer space (0-15 out of 16) in both
+                    reads and reference.  Increases speed and reduces memory.
+Note: Do not use more than one of 'speed', 'qskip', and 'rskip'.
+
+Trimming/Filtering/Masking parameters:
+Note - if ktrim, kmask, and ksplit are unset, the default behavior is kfilter.
+All kmer processing modes are mutually exclusive.
+Reads only get sent to 'outm' purely based on kmer matches in kfilter mode.
+
+ktrim=f             Trim reads to remove bases matching reference kmers, plus
+                    all bases to the left or right.
+                    Values: 
+                       f (don't trim), 
+                       r (trim to the right), 
+                       l (trim to the left)
+ktrimtips=0         Set this to a positive number to perform ktrim on both
+                    ends, examining only the outermost X bases.
+kmask=              Replace bases matching ref kmers with another symbol.
+                    Allows any non-whitespace character, and processes short
+                    kmers on both ends if mink is set.  'kmask=lc' will
+                    convert masked bases to lowercase.
+maskfullycovered=f  (mfc) Only mask bases that are fully covered by kmers.
+ksplit=f            For single-ended reads only.  Reads will be split into
+                    pairs around the kmer.  If the kmer is at the end of the
+                    read, it will be trimmed instead.  Singletons will go to
+                    out, and pairs will go to outm.  Do not use ksplit with
+                    other operations such as quality-trimming or filtering.
+mink=0              Look for shorter kmers at read tips down to this length, 
+                    when k-trimming or masking.  0 means disabled.  Enabling
+                    this will disable maskmiddle.
+qtrim=f             Trim read ends to remove bases with quality below trimq.
+                    Performed AFTER looking for kmers.  Values: 
+                       rl (trim both ends), 
+                       f (neither end), 
+                       r (right end only), 
+                       l (left end only),
+                       w (sliding window).
+trimq=6             Regions with average quality BELOW this will be trimmed,
+                    if qtrim is set to something other than f.  Can be a 
+                    floating-point number like 7.3.
+trimclip=f          Trim soft-clipped bases from sam files.
+minlength=10        (ml) Reads shorter than this after trimming will be 
+                    discarded.  Pairs will be discarded if both are shorter.
+mlf=0               (minlengthfraction) Reads shorter than this fraction of 
+                    original length after trimming will be discarded.
+maxlength=          Reads longer than this after trimming will be discarded.
+minavgquality=0     (maq) Reads with average quality (after trimming) below 
+                    this will be discarded.
+maqb=0              If positive, calculate maq from this many initial bases.
+minbasequality=0    (mbq) Reads with any base below this quality (after 
+                    trimming) will be discarded.
+maxns=-1            If non-negative, reads with more Ns than this 
+                    (after trimming) will be discarded.
+mcb=0               (minconsecutivebases) Discard reads without at least 
+                    this many consecutive called bases.
+ottm=f              (outputtrimmedtomatch) Output reads trimmed to shorter 
+                    than minlength to outm rather than discarding.
+tp=0                (trimpad) Trim this much extra around matching kmers.
+tbo=f               (trimbyoverlap) Trim adapters based on where paired 
+                    reads overlap.
+strictoverlap=t     Adjust sensitivity for trimbyoverlap mode.
+minoverlap=14       Require this many bases of overlap for detection.
+mininsert=40        Require insert size of at least this for overlap.
+                    Should be reduced to 16 for small RNA sequencing.
+tpe=f               (trimpairsevenly) When kmer right-trimming, trim both 
+                    reads to the minimum length of either.
+forcetrimleft=0     (ftl) If positive, trim bases to the left of this position
+                    (exclusive, 0-based).
+forcetrimright=0    (ftr) If positive, trim bases to the right of this position
+                    (exclusive, 0-based).
+forcetrimright2=0   (ftr2) If positive, trim this many bases on the right end.
+forcetrimmod=0      (ftm) If positive, right-trim length to be equal to zero,
+                    modulo this number.
+restrictleft=0      If positive, only look for kmer matches in the 
+                    leftmost X bases.
+restrictright=0     If positive, only look for kmer matches in the 
+                    rightmost X bases.
+NOTE:  restrictleft and restrictright are mutually exclusive.  If trimming
+       both ends is desired, use ktrimtips.
+mingc=0             Discard reads with GC content below this.
+maxgc=1             Discard reads with GC content above this.
+gcpairs=t           Use average GC of paired reads.
+                    Also affects gchist.
+tossjunk=f          Discard reads with invalid characters as bases.
+swift=f             Trim Swift sequences: Trailing C/T/N R1, leading G/A/N R2.
+
+Header-parsing parameters - these require Illumina headers:
+chastityfilter=f    (cf) Discard reads with id containing ' 1:Y:' or ' 2:Y:'.
+barcodefilter=f     Remove reads with unexpected barcodes if barcodes is set,
+                    or barcodes containing 'N' otherwise.  A barcode must be
+                    the last part of the read header.  Values:
+                       t:     Remove reads with bad barcodes.
+                       f:     Ignore barcodes.
+                       crash: Crash upon encountering bad barcodes.
+barcodes=           Comma-delimited list of barcodes or files of barcodes.
+xmin=-1             If positive, discard reads with a lesser X coordinate.
+ymin=-1             If positive, discard reads with a lesser Y coordinate.
+xmax=-1             If positive, discard reads with a greater X coordinate.
+ymax=-1             If positive, discard reads with a greater Y coordinate.
+
+Polymer trimming:
+trimpolya=0         If greater than 0, trim poly-A or poly-T tails of
+                    at least this length on either end of reads.
+trimpolygleft=0     If greater than 0, trim poly-G prefixes of at least this
+                    length on the left end of reads.  Does not trim poly-C.
+trimpolygright=0    If greater than 0, trim poly-G tails of at least this 
+                    length on the right end of reads.  Does not trim poly-C.
+trimpolyg=0         This sets both left and right at once.
+filterpolyg=0       If greater than 0, remove reads with a poly-G prefix of
+                    at least this length (on the left).
+Note: there are also equivalent poly-C flags.
+
+Polymer tracking:
+pratio=base,base    'pratio=G,C' will print the ratio of G to C polymers.
+plen=20             Length of homopolymers to count.
+
+Entropy/Complexity parameters:
+entropy=-1          Set between 0 and 1 to filter reads with entropy below
+                    that value.  Higher is more stringent.
+entropywindow=50    Calculate entropy using a sliding window of this length.
+entropyk=5          Calculate entropy using kmers of this length.
+minbasefrequency=0  Discard reads with a minimum base frequency below this.
+entropytrim=f       Values:
+                       f:  (false) Do not entropy-trim.
+                       r:  (right) Trim low entropy on the right end only.
+                       l:  (left) Trim low entropy on the left end only.
+                       rl: (both) Trim low entropy on both ends.
+entropymask=f       Values:
+                       f:  (filter) Discard low-entropy sequences.
+                       t:  (true) Mask low-entropy parts of sequences with N.
+                       lc: Change low-entropy parts of sequences to lowercase.
+entropymark=f       Mark each base with its entropy value.  This is on a scale
+                    of 0-41 and is reported as quality scores, so the output
+                    should be fastq or fasta+qual.
+NOTE: If set, entropytrim overrides entropymask.
+
+Cardinality estimation:
+cardinality=f       (loglog) Count unique kmers using the LogLog algorithm.
+cardinalityout=f    (loglogout) Count unique kmers in output reads.
+loglogk=31          Use this kmer length for counting.
+loglogbuckets=2048  Use this many buckets for counting.
+khist=<file>        Kmer frequency histogram; plots number of kmers versus
+                    kmer depth.  This is approximate.
+khistout=<file>     Kmer frequency histogram for output reads.
+
+Java Parameters:
+
+-Xmx                This will set Java's memory usage, overriding autodetection.
+                    -Xmx20g will 
+                    specify 20 gigs of RAM, and -Xmx200m will specify 200 megs.  
+                    The max is typically 85% of physical memory.
+-eoom               This flag will cause the process to exit if an 
+                    out-of-memory exception occurs.  Requires Java 8u92+.
+-da                 Disable assertions.
+
+Please contact Brian Bushnell at bbushnell@lbl.gov if you encounter any problems.
+
diff --git a/tests/tool_audit/help/ciri2.txt b/tests/tool_audit/help/ciri2.txt
new file mode 100644
index 00000000..52daf519
--- /dev/null
+++ b/tests/tool_audit/help/ciri2.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+FATAL:   "CIRI2.pl": executable file not found in $PATH
diff --git a/tests/tool_audit/help/cutadapt_help.txt b/tests/tool_audit/help/cutadapt_help.txt
new file mode 100644
index 00000000..b2bc691f
--- /dev/null
+++ b/tests/tool_audit/help/cutadapt_help.txt
@@ -0,0 +1,220 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+cutadapt version 4.1
+
+Copyright (C) 2010-2022 Marcel Martin <marcel.martin@scilifelab.se>
+
+cutadapt removes adapter sequences from high-throughput sequencing reads.
+
+Usage:
+    cutadapt -a ADAPTER [options] [-o output.fastq] input.fastq
+
+For paired-end reads:
+    cutadapt -a ADAPT1 -A ADAPT2 [options] -o out1.fastq -p out2.fastq in1.fastq in2.fastq
+
+Replace "ADAPTER" with the actual sequence of your 3' adapter. IUPAC wildcard
+characters are supported. All reads from input.fastq will be written to
+output.fastq with the adapter sequence removed. Adapter matching is
+error-tolerant. Multiple adapter sequences can be given (use further -a
+options), but only the best-matching adapter will be removed.
+
+Input may also be in FASTA format. Compressed input and output is supported and
+auto-detected from the file name (.gz, .xz, .bz2). Use the file name '-' for
+standard input/output. Without the -o option, output is sent to standard output.
+
+Citation:
+
+Marcel Martin. Cutadapt removes adapter sequences from high-throughput
+sequencing reads. EMBnet.Journal, 17(1):10-12, May 2011.
+http://dx.doi.org/10.14806/ej.17.1.200
+
+Run "cutadapt --help" to see all command-line options.
+See https://cutadapt.readthedocs.io/ for full documentation.
+
+Options:
+  -h, --help            Show this help message and exit
+  --version             Show version number and exit
+  --debug               Print debug log. Use twice to also print DP matrices
+  -j CORES, --cores CORES
+                        Number of CPU cores to use. Use 0 to auto-detect.
+                        Default: 1
+
+Finding adapters:
+  Parameters -a, -g, -b specify adapters to be removed from each read (or from
+  R1 if data is paired-end. If specified multiple times, only the best
+  matching adapter is trimmed (but see the --times option). Use notation
+  'file:FILE' to read adapter sequences from a FASTA file.
+
+  -a ADAPTER, --adapter ADAPTER
+                        Sequence of an adapter ligated to the 3' end (paired
+                        data: of the first read). The adapter and subsequent
+                        bases are trimmed. If a '$' character is appended
+                        ('anchoring'), the adapter is only found if it is a
+                        suffix of the read.
+  -g ADAPTER, --front ADAPTER
+                        Sequence of an adapter ligated to the 5' end (paired
+                        data: of the first read). The adapter and any preceding
+                        bases are trimmed. Partial matches at the 5' end are
+                        allowed. If a '^' character is prepended ('anchoring'),
+                        the adapter is only found if it is a prefix of the read.
+  -b ADAPTER, --anywhere ADAPTER
+                        Sequence of an adapter that may be ligated to the 5' or
+                        3' end (paired data: of the first read). Both types of
+                        matches as described under -a and -g are allowed. If the
+                        first base of the read is part of the match, the
+                        behavior is as with -g, otherwise as with -a. This
+                        option is mostly for rescuing failed library
+                        preparations - do not use if you know which end your
+                        adapter was ligated to!
+  -e E, --error-rate E, --errors E
+                        Maximum allowed error rate (if 0 <= E < 1), or absolute
+                        number of errors for full-length adapter match (if E is
+                        an integer >= 1). Error rate = no. of errors divided by
+                        length of matching region. Default: 0.1 (10%)
+  --no-indels           Allow only mismatches in alignments. Default: allow both
+                        mismatches and indels
+  -n COUNT, --times COUNT
+                        Remove up to COUNT adapters from each read. Default: 1
+  -O MINLENGTH, --overlap MINLENGTH
+                        Require MINLENGTH overlap between read and adapter for
+                        an adapter to be found. Default: 3
+  --match-read-wildcards
+                        Interpret IUPAC wildcards in reads. Default: False
+  -N, --no-match-adapter-wildcards
+                        Do not interpret IUPAC wildcards in adapters.
+  --action {trim,retain,mask,lowercase,none}
+                        What to do if a match was found. trim: trim adapter and
+                        up- or downstream sequence; retain: trim, but retain
+                        adapter; mask: replace with 'N' characters; lowercase:
+                        convert to lowercase; none: leave unchanged. Default:
+                        trim
+  --rc, --revcomp       Check both the read and its reverse complement for
+                        adapter matches. If match is on reverse-complemented
+                        version, output that one. Default: check only read
+
+Additional read modifications:
+  -u LENGTH, --cut LENGTH
+                        Remove bases from each read (first read only if paired).
+                        If LENGTH is positive, remove bases from the beginning.
+                        If LENGTH is negative, remove bases from the end. Can be
+                        used twice if LENGTHs have different signs. This is
+                        applied *before* adapter trimming.
+  --nextseq-trim 3'CUTOFF
+                        NextSeq-specific quality trimming (each read). Trims
+                        also dark cycles appearing as high-quality G bases.
+  -q [5'CUTOFF,]3'CUTOFF, --quality-cutoff [5'CUTOFF,]3'CUTOFF
+                        Trim low-quality bases from 5' and/or 3' ends of each
+                        read before adapter removal. Applied to both reads if
+                        data is paired. If one value is given, only the 3' end
+                        is trimmed. If two comma-separated cutoffs are given,
+                        the 5' end is trimmed with the first cutoff, the 3' end
+                        with the second.
+  --quality-base N      Assume that quality values in FASTQ are encoded as
+                        ascii(quality + N). This needs to be set to 64 for some
+                        old Illumina FASTQ files. Default: 33
+  --length LENGTH, -l LENGTH
+                        Shorten reads to LENGTH. Positive values remove bases at
+                        the end while negative ones remove bases at the
+                        beginning. This and the following modifications are
+                        applied after adapter trimming.
+  --trim-n              Trim N's on ends of reads.
+  --length-tag TAG      Search for TAG followed by a decimal number in the
+                        description field of the read. Replace the decimal
+                        number with the correct length of the trimmed read. For
+                        example, use --length-tag 'length=' to correct fields
+                        like 'length=123'.
+  --strip-suffix STRIP_SUFFIX
+                        Remove this suffix from read names if present. Can be
+                        given multiple times.
+  -x PREFIX, --prefix PREFIX
+                        Add this prefix to read names. Use {name} to insert the
+                        name of the matching adapter.
+  -y SUFFIX, --suffix SUFFIX
+                        Add this suffix to read names; can also include {name}
+  --rename TEMPLATE     Rename reads using TEMPLATE containing variables such as
+                        {id}, {adapter_name} etc. (see documentation)
+  --zero-cap, -z        Change negative quality values to zero.
+
+Filtering of processed reads:
+  Filters are applied after above read modifications. Paired-end reads are
+  always discarded pairwise (see also --pair-filter).
+
+  -m LEN[:LEN2], --minimum-length LEN[:LEN2]
+                        Discard reads shorter than LEN. Default: 0
+  -M LEN[:LEN2], --maximum-length LEN[:LEN2]
+                        Discard reads longer than LEN. Default: no limit
+  --max-n COUNT         Discard reads with more than COUNT 'N' bases. If COUNT
+                        is a number between 0 and 1, it is interpreted as a
+                        fraction of the read length.
+  --max-expected-errors ERRORS, --max-ee ERRORS
+                        Discard reads whose expected number of errors (computed
+                        from quality values) exceeds ERRORS.
+  --discard-trimmed, --discard
+                        Discard reads that contain an adapter. Use also -O to
+                        avoid discarding too many randomly matching reads.
+  --discard-untrimmed, --trimmed-only
+                        Discard reads that do not contain an adapter.
+  --discard-casava      Discard reads that did not pass CASAVA filtering (header
+                        has :Y:).
+
+Output:
+  --quiet               Print only error messages.
+  --report {full,minimal}
+                        Which type of report to print: 'full' or 'minimal'.
+                        Default: full
+  --json FILE           Dump report in JSON format to FILE
+  -o FILE, --output FILE
+                        Write trimmed reads to FILE. FASTQ or FASTA format is
+                        chosen depending on input. Summary report is sent to
+                        standard output. Use '{name}' for demultiplexing (see
+                        docs). Default: write to standard output
+  --fasta               Output FASTA to standard output even on FASTQ input.
+  -Z                    Use compression level 1 for gzipped output files
+                        (faster, but uses more space)
+  --info-file FILE      Write information about each read and its adapter
+                        matches into FILE. See the documentation for the file
+                        format.
+  -r FILE, --rest-file FILE
+                        When the adapter matches in the middle of a read, write
+                        the rest (after the adapter) to FILE.
+  --wildcard-file FILE  When the adapter has N wildcard bases, write adapter
+                        bases matching wildcard positions to FILE. (Inaccurate
+                        with indels.)
+  --too-short-output FILE
+                        Write reads that are too short (according to length
+                        specified by -m) to FILE. Default: discard reads
+  --too-long-output FILE
+                        Write reads that are too long (according to length
+                        specified by -M) to FILE. Default: discard reads
+  --untrimmed-output FILE
+                        Write reads that do not contain any adapter to FILE.
+                        Default: output to same file as trimmed reads
+
+Paired-end options:
+  The -A/-G/-B/-U/-Q options work like their lowercase counterparts, but are
+  applied to R2 (second read in pair)
+
+  -A ADAPTER            3' adapter to be removed from R2
+  -G ADAPTER            5' adapter to be removed from R2
+  -B ADAPTER            5'/3 adapter to be removed from R2
+  -U LENGTH             Remove LENGTH bases from R2
+  -Q [5'CUTOFF,]3'CUTOFF
+                        Quality-trimming cutoff for R2. Default: same as for R1
+  -p FILE, --paired-output FILE
+                        Write R2 to FILE.
+  --pair-adapters       Treat adapters given with -a/-A etc. as pairs. Either
+                        both or none are removed from each read pair.
+  --pair-filter {any,both,first}
+                        Which of the reads in a paired-end read have to match
+                        the filtering criterion in order for the pair to be
+                        filtered. Default: any
+  --interleaved         Read and/or write interleaved paired-end reads.
+  --untrimmed-paired-output FILE
+                        Write second read in a pair to this FILE when no adapter
+                        was found. Use with --untrimmed-output. Default: output
+                        to same file as trimmed reads
+  --too-short-paired-output FILE
+                        Write second read in a pair to this file if pair is too
+                        short.
+  --too-long-paired-output FILE
+                        Write second read in a pair to this file if pair is too
+                        long.
diff --git a/tests/tool_audit/help/dorado.txt b/tests/tool_audit/help/dorado.txt
new file mode 100644
index 00000000..5352f805
--- /dev/null
+++ b/tests/tool_audit/help/dorado.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+FATAL:   "dorado": executable file not found in $PATH
diff --git a/tests/tool_audit/help/fastp_help.txt b/tests/tool_audit/help/fastp_help.txt
new file mode 100644
index 00000000..bd2cb16c
--- /dev/null
+++ b/tests/tool_audit/help/fastp_help.txt
@@ -0,0 +1,90 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: /opt/conda/envs/monsda/bin/fastp [options] ... 
+options:
+  -i, --in1                            read1 input file name (string [=])
+  -o, --out1                           read1 output file name (string [=])
+  -I, --in2                            read2 input file name (string [=])
+  -O, --out2                           read2 output file name (string [=])
+      --unpaired1                      for PE input, if read1 passed QC but read2 not, it will be written to unpaired1. Default is to discard it. (string [=])
+      --unpaired2                      for PE input, if read2 passed QC but read1 not, it will be written to unpaired2. If --unpaired2 is same as --unpaired1 (default mode), both unpaired reads will be written to this same file. (string [=])
+      --overlapped_out                 for each read pair, output the overlapped region if it has no any mismatched base. (string [=])
+      --failed_out                     specify the file to store reads that cannot pass the filters. (string [=])
+  -m, --merge                          for paired-end input, merge each pair of reads into a single read if they are overlapped. The merged reads will be written to the file given by --merged_out, the unmerged reads will be written to the files specified by --out1 and --out2. The merging mode is disabled by default.
+      --merged_out                     in the merging mode, specify the file name to store merged output, or specify --stdout to stream the merged output (string [=])
+      --include_unmerged               in the merging mode, write the unmerged or unpaired reads to the file specified by --merge. Disabled by default.
+  -6, --phred64                        indicate the input is using phred64 scoring (it'll be converted to phred33, so the output will still be phred33)
+  -z, --compression                    compression level for gzip output (1 ~ 9). 1 is fastest, 9 is smallest, default is 4. (int [=4])
+      --stdin                          input from STDIN. If the STDIN is interleaved paired-end FASTQ, please also add --interleaved_in.
+      --stdout                         stream passing-filters reads to STDOUT. This option will result in interleaved FASTQ output for paired-end output. Disabled by default.
+      --interleaved_in                 indicate that <in1> is an interleaved FASTQ which contains both read1 and read2. Disabled by default.
+      --reads_to_process               specify how many reads/pairs to be processed. Default 0 means process all reads. (int [=0])
+      --dont_overwrite                 don't overwrite existing files. Overwritting is allowed by default.
+      --fix_mgi_id                     the MGI FASTQ ID format is not compatible with many BAM operation tools, enable this option to fix it.
+  -V, --verbose                        output verbose log information (i.e. when every 1M reads are processed).
+  -A, --disable_adapter_trimming       adapter trimming is enabled by default. If this option is specified, adapter trimming is disabled
+  -a, --adapter_sequence               the adapter for read1. For SE data, if not specified, the adapter will be auto-detected. For PE data, this is used if R1/R2 are found not overlapped. (string [=auto])
+      --adapter_sequence_r2            the adapter for read2 (PE data only). This is used if R1/R2 are found not overlapped. If not specified, it will be the same as <adapter_sequence> (string [=auto])
+      --adapter_fasta                  specify a FASTA file to trim both read1 and read2 (if PE) by all the sequences in this FASTA file (string [=])
+      --detect_adapter_for_pe          by default, the auto-detection for adapter is for SE data input only, turn on this option to enable it for PE data.
+  -f, --trim_front1                    trimming how many bases in front for read1, default is 0 (int [=0])
+  -t, --trim_tail1                     trimming how many bases in tail for read1, default is 0 (int [=0])
+  -b, --max_len1                       if read1 is longer than max_len1, then trim read1 at its tail to make it as long as max_len1. Default 0 means no limitation (int [=0])
+  -F, --trim_front2                    trimming how many bases in front for read2. If it's not specified, it will follow read1's settings (int [=0])
+  -T, --trim_tail2                     trimming how many bases in tail for read2. If it's not specified, it will follow read1's settings (int [=0])
+  -B, --max_len2                       if read2 is longer than max_len2, then trim read2 at its tail to make it as long as max_len2. Default 0 means no limitation. If it's not specified, it will follow read1's settings (int [=0])
+  -D, --dedup                          enable deduplication to drop the duplicated reads/pairs
+      --dup_calc_accuracy              accuracy level to calculate duplication (1~6), higher level uses more memory (1G, 2G, 4G, 8G, 16G, 24G). Default 1 for no-dedup mode, and 3 for dedup mode. (int [=0])
+      --dont_eval_duplication          don't evaluate duplication rate to save time and use less memory.
+  -g, --trim_poly_g                    force polyG tail trimming, by default trimming is automatically enabled for Illumina NextSeq/NovaSeq data
+      --poly_g_min_len                 the minimum length to detect polyG in the read tail. 10 by default. (int [=10])
+  -G, --disable_trim_poly_g            disable polyG tail trimming, by default trimming is automatically enabled for Illumina NextSeq/NovaSeq data
+  -x, --trim_poly_x                    enable polyX trimming in 3' ends.
+      --poly_x_min_len                 the minimum length to detect polyX in the read tail. 10 by default. (int [=10])
+  -5, --cut_front                      move a sliding window from front (5') to tail, drop the bases in the window if its mean quality < threshold, stop otherwise.
+  -3, --cut_tail                       move a sliding window from tail (3') to front, drop the bases in the window if its mean quality < threshold, stop otherwise.
+  -r, --cut_right                      move a sliding window from front to tail, if meet one window with mean quality < threshold, drop the bases in the window and the right part, and then stop.
+  -W, --cut_window_size                the window size option shared by cut_front, cut_tail or cut_sliding. Range: 1~1000, default: 4 (int [=4])
+  -M, --cut_mean_quality               the mean quality requirement option shared by cut_front, cut_tail or cut_sliding. Range: 1~36 default: 20 (Q20) (int [=20])
+      --cut_front_window_size          the window size option of cut_front, default to cut_window_size if not specified (int [=4])
+      --cut_front_mean_quality         the mean quality requirement option for cut_front, default to cut_mean_quality if not specified (int [=20])
+      --cut_tail_window_size           the window size option of cut_tail, default to cut_window_size if not specified (int [=4])
+      --cut_tail_mean_quality          the mean quality requirement option for cut_tail, default to cut_mean_quality if not specified (int [=20])
+      --cut_right_window_size          the window size option of cut_right, default to cut_window_size if not specified (int [=4])
+      --cut_right_mean_quality         the mean quality requirement option for cut_right, default to cut_mean_quality if not specified (int [=20])
+  -Q, --disable_quality_filtering      quality filtering is enabled by default. If this option is specified, quality filtering is disabled
+  -q, --qualified_quality_phred        the quality value that a base is qualified. Default 15 means phred quality >=Q15 is qualified. (int [=15])
+  -u, --unqualified_percent_limit      how many percents of bases are allowed to be unqualified (0~100). Default 40 means 40% (int [=40])
+  -n, --n_base_limit                   if one read's number of N base is >n_base_limit, then this read/pair is discarded. Default is 5 (int [=5])
+  -e, --average_qual                   if one read's average quality score <avg_qual, then this read/pair is discarded. Default 0 means no requirement (int [=0])
+  -L, --disable_length_filtering       length filtering is enabled by default. If this option is specified, length filtering is disabled
+  -l, --length_required                reads shorter than length_required will be discarded, default is 15. (int [=15])
+      --length_limit                   reads longer than length_limit will be discarded, default 0 means no limitation. (int [=0])
+  -y, --low_complexity_filter          enable low complexity filter. The complexity is defined as the percentage of base that is different from its next base (base[i] != base[i+1]).
+  -Y, --complexity_threshold           the threshold for low complexity filter (0~100). Default is 30, which means 30% complexity is required. (int [=30])
+      --filter_by_index1               specify a file contains a list of barcodes of index1 to be filtered out, one barcode per line (string [=])
+      --filter_by_index2               specify a file contains a list of barcodes of index2 to be filtered out, one barcode per line (string [=])
+      --filter_by_index_threshold      the allowed difference of index barcode for index filtering, default 0 means completely identical. (int [=0])
+  -c, --correction                     enable base correction in overlapped regions (only for PE data), default is disabled
+      --overlap_len_require            the minimum length to detect overlapped region of PE reads. This will affect overlap analysis based PE merge, adapter trimming and correction. 30 by default. (int [=30])
+      --overlap_diff_limit             the maximum number of mismatched bases to detect overlapped region of PE reads. This will affect overlap analysis based PE merge, adapter trimming and correction. 5 by default. (int [=5])
+      --overlap_diff_percent_limit     the maximum percentage of mismatched bases to detect overlapped region of PE reads. This will affect overlap analysis based PE merge, adapter trimming and correction. Default 20 means 20%. (int [=20])
+  -U, --umi                            enable unique molecular identifier (UMI) preprocessing
+      --umi_loc                        specify the location of UMI, can be (index1/index2/read1/read2/per_index/per_read, default is none (string [=])
+      --umi_len                        if the UMI is in read1/read2, its length should be provided (int [=0])
+      --umi_prefix                     if specified, an underline will be used to connect prefix and UMI (i.e. prefix=UMI, UMI=AATTCG, final=UMI_AATTCG). No prefix by default (string [=])
+      --umi_skip                       if the UMI is in read1/read2, fastp can skip several bases following UMI, default is 0 (int [=0])
+      --umi_delim                      delimiter to use between the read name and the UMI, default is : (string [=:])
+  -p, --overrepresentation_analysis    enable overrepresented sequence analysis.
+  -P, --overrepresentation_sampling    one in (--overrepresentation_sampling) reads will be computed for overrepresentation analysis (1~10000), smaller is slower, default is 20. (int [=20])
+  -j, --json                           the json format report file name (string [=fastp.json])
+  -h, --html                           the html format report file name (string [=fastp.html])
+  -R, --report_title                   should be quoted with ' or ", default is "fastp report" (string [=fastp report])
+  -w, --thread                         worker thread number, default is 3 (int [=3])
+  -s, --split                          split output by limiting total split file number with this option (2~999), a sequential number prefix will be added to output name ( 0001.out.fq, 0002.out.fq...), disabled by default (int [=0])
+  -S, --split_by_lines                 split output by limiting lines of each file with this option(>=1000), a sequential number prefix will be added to output name ( 0001.out.fq, 0002.out.fq...), disabled by default (long [=0])
+  -d, --split_prefix_digits            the digits for the sequential number padding (1~10), default is 4, so the filename will be padded as 0001.xxx, 0 to disable padding (int [=4])
+      --cut_by_quality5                DEPRECATED, use --cut_front instead.
+      --cut_by_quality3                DEPRECATED, use --cut_tail instead.
+      --cut_by_quality_aggressive      DEPRECATED, use --cut_right instead.
+      --discard_unmerged               DEPRECATED, no effect now, see the introduction for merging.
+  -?, --help                           print this message
diff --git a/tests/tool_audit/help/fgumi.txt b/tests/tool_audit/help/fgumi.txt
new file mode 100644
index 00000000..7fbcd3d6
--- /dev/null
+++ b/tests/tool_audit/help/fgumi.txt
@@ -0,0 +1,27 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Usage: fgumi [OPTIONS] <COMMAND>
+
+Commands:
+  extract          [UMI EXTRACTION] Extract UMIs from FASTQ and create unmapped BAM
+  correct          [UMI EXTRACTION] Correct UMIs in a BAM file to a fixed set of UMIs
+  fastq            [ALIGNMENT]      Convert BAM to FASTQ format
+  zipper           [ALIGNMENT]      Zip unmapped BAM with aligned BAM
+  sort             [ALIGNMENT]      Sort BAM file by coordinate, queryname, or template-coordinate
+  merge            [ALIGNMENT]      Merge pre-sorted BAM files into a single sorted BAM
+  group            [GROUP]          Group reads by UMI to identify reads from the same original molecule
+  dedup            [DEDUP]         Mark or remove PCR duplicates using UMI information
+  simplex          [CONSENSUS]      Call simplex consensus sequences from UMI-grouped reads
+  duplex           [CONSENSUS]      Call duplex consensus sequences from UMI-grouped reads
+  codec            [CONSENSUS]      Call CODEC consensus reads from grouped BAM
+  filter           [POST-CONSENSUS] Filter consensus reads based on quality metrics
+  clip             [POST-CONSENSUS] Clip overlapping reads in BAM files
+  duplex-metrics   [POST-CONSENSUS] Collect QC metrics for duplex consensus reads
+  simplex-metrics  [POST-CONSENSUS] Collect QC metrics for simplex sequencing data
+  review           [POST-CONSENSUS] Extract data to review variant calls from consensus reads
+  downsample       [UTILITIES]      Downsample BAM by UMI family using streaming
+  help             Print this message or the help of the given subcommand(s)
+
+Options:
+  -v, --verbose  Enable verbose (debug-level) logging. Equivalent to setting `RUST_LOG=debug`
+  -h, --help     Print help
+  -V, --version  Print version
diff --git a/tests/tool_audit/help/guppy.txt b/tests/tool_audit/help/guppy.txt
new file mode 100644
index 00000000..505c4f02
--- /dev/null
+++ b/tests/tool_audit/help/guppy.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+FATAL:   "guppy_basecaller": executable file not found in $PATH
diff --git a/tests/tool_audit/help/hisat2.txt b/tests/tool_audit/help/hisat2.txt
new file mode 100644
index 00000000..2fec35bd
--- /dev/null
+++ b/tests/tool_audit/help/hisat2.txt
@@ -0,0 +1,141 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+HISAT2 version 2.2.1 by Daehwan Kim (infphilo@gmail.com, www.ccb.jhu.edu/people/infphilo)
+Usage: 
+  hisat2 [options]* -x <ht2-idx> {-1 <m1> -2 <m2> | -U <r>} [-S <sam>]
+
+  <ht2-idx>  Index filename prefix (minus trailing .X.ht2).
+  <m1>       Files with #1 mates, paired with files in <m2>.
+             Could be gzip'ed (extension: .gz) or bzip2'ed (extension: .bz2).
+  <m2>       Files with #2 mates, paired with files in <m1>.
+             Could be gzip'ed (extension: .gz) or bzip2'ed (extension: .bz2).
+  <r>        Files with unpaired reads.
+             Could be gzip'ed (extension: .gz) or bzip2'ed (extension: .bz2).
+  <sam>      File for SAM output (default: stdout)
+
+  <m1>, <m2>, <r> can be comma-separated lists (no whitespace) and can be
+  specified many times.  E.g. '-U file1.fq,file2.fq -U file3.fq'.
+
+Options (defaults in parentheses):
+
+ Input:
+  -q                 query input files are FASTQ .fq/.fastq (default)
+  --qseq             query input files are in Illumina's qseq format
+  -f                 query input files are (multi-)FASTA .fa/.mfa
+  -r                 query input files are raw one-sequence-per-line
+  -c                 <m1>, <m2>, <r> are sequences themselves, not files
+  -s/--skip <int>    skip the first <int> reads/pairs in the input (none)
+  -u/--upto <int>    stop after first <int> reads/pairs (no limit)
+  -5/--trim5 <int>   trim <int> bases from 5'/left end of reads (0)
+  -3/--trim3 <int>   trim <int> bases from 3'/right end of reads (0)
+  --phred33          qualities are Phred+33 (default)
+  --phred64          qualities are Phred+64
+  --int-quals        qualities encoded as space-delimited integers
+
+ Presets:                 Same as:
+   --fast                 --no-repeat-index
+   --sensitive            --bowtie2-dp 1 -k 30 --score-min L,0,-0.5
+   --very-sensitive       --bowtie2-dp 2 -k 50 --score-min L,0,-1
+
+ Alignment:
+  --bowtie2-dp <int> use Bowtie2's dynamic programming alignment algorithm (0) - 0: no dynamic programming, 1: conditional dynamic programming, and 2: unconditional dynamic programming (slowest)
+  --n-ceil <func>    func for max # non-A/C/G/Ts permitted in aln (L,0,0.15)
+  --ignore-quals     treat all quality values as 30 on Phred scale (off)
+  --nofw             do not align forward (original) version of read (off)
+  --norc             do not align reverse-complement version of read (off)
+  --no-repeat-index  do not use repeat index
+
+ Spliced Alignment:
+  --pen-cansplice <int>              penalty for a canonical splice site (0)
+  --pen-noncansplice <int>           penalty for a non-canonical splice site (12)
+  --pen-canintronlen <func>          penalty for long introns (G,-8,1) with canonical splice sites
+  --pen-noncanintronlen <func>       penalty for long introns (G,-8,1) with noncanonical splice sites
+  --min-intronlen <int>              minimum intron length (20)
+  --max-intronlen <int>              maximum intron length (500000)
+  --known-splicesite-infile <path>   provide a list of known splice sites
+  --novel-splicesite-outfile <path>  report a list of splice sites
+  --novel-splicesite-infile <path>   provide a list of novel splice sites
+  --no-temp-splicesite               disable the use of splice sites found
+  --no-spliced-alignment             disable spliced alignment
+  --rna-strandness <string>          specify strand-specific information (unstranded)
+  --tmo                              reports only those alignments within known transcriptome
+  --dta                              reports alignments tailored for transcript assemblers
+  --dta-cufflinks                    reports alignments tailored specifically for cufflinks
+  --avoid-pseudogene                 tries to avoid aligning reads to pseudogenes (experimental option)
+  --no-templatelen-adjustment        disables template length adjustment for RNA-seq reads
+
+ Scoring:
+  --mp <int>,<int>   max and min penalties for mismatch; lower qual = lower penalty <6,2>
+  --sp <int>,<int>   max and min penalties for soft-clipping; lower qual = lower penalty <2,1>
+  --no-softclip      no soft-clipping
+  --np <int>         penalty for non-A/C/G/Ts in read/ref (1)
+  --rdg <int>,<int>  read gap open, extend penalties (5,3)
+  --rfg <int>,<int>  reference gap open, extend penalties (5,3)
+  --score-min <func> min acceptable alignment score w/r/t read length
+                     (L,0.0,-0.2)
+
+ Reporting:
+  -k <int>           It searches for at most <int> distinct, primary alignments for each read. Primary alignments mean 
+                     alignments whose alignment score is equal to or higher than any other alignments. The search terminates 
+                     when it cannot find more distinct valid alignments, or when it finds <int>, whichever happens first. 
+                     The alignment score for a paired-end alignment equals the sum of the alignment scores of 
+                     the individual mates. Each reported read or pair alignment beyond the first has the SAM ‘secondary’ bit 
+                     (which equals 256) set in its FLAGS field. For reads that have more than <int> distinct, 
+                     valid alignments, hisat2 does not guarantee that the <int> alignments reported are the best possible 
+                     in terms of alignment score. Default: 5 (linear index) or 10 (graph index).
+                     Note: HISAT2 is not designed with large values for -k in mind, and when aligning reads to long, 
+                     repetitive genomes, large -k could make alignment much slower.
+  --max-seeds <int>  HISAT2, like other aligners, uses seed-and-extend approaches. HISAT2 tries to extend seeds to 
+                     full-length alignments. In HISAT2, --max-seeds is used to control the maximum number of seeds that 
+                     will be extended. For DNA-read alignment (--no-spliced-alignment), HISAT2 extends up to these many seeds
+                     and skips the rest of the seeds. For RNA-read alignment, HISAT2 skips extending seeds and reports 
+                     no alignments if the number of seeds is larger than the number specified with the option, 
+                     to be compatible with previous versions of HISAT2. Large values for --max-seeds may improve alignment 
+                     sensitivity, but HISAT2 is not designed with large values for --max-seeds in mind, and when aligning 
+                     reads to long, repetitive genomes, large --max-seeds could make alignment much slower. 
+                     The default value is the maximum of 5 and the value that comes with -k times 2.
+  -a/--all           HISAT2 reports all alignments it can find. Using the option is equivalent to using both --max-seeds 
+                     and -k with the maximum value that a 64-bit signed integer can represent (9,223,372,036,854,775,807).
+  --repeat           report alignments to repeat sequences directly
+
+ Paired-end:
+  -I/--minins <int>  minimum fragment length (0), only valid with --no-spliced-alignment
+  -X/--maxins <int>  maximum fragment length (500), only valid with --no-spliced-alignment
+  --fr/--rf/--ff     -1, -2 mates align fw/rev, rev/fw, fw/fw (--fr)
+  --no-mixed         suppress unpaired alignments for paired reads
+  --no-discordant    suppress discordant alignments for paired reads
+
+ Output:
+  -t/--time          print wall-clock time taken by search phases
+  --un <path>           write unpaired reads that didn't align to <path>
+  --al <path>           write unpaired reads that aligned at least once to <path>
+  --un-conc <path>      write pairs that didn't align concordantly to <path>
+  --al-conc <path>      write pairs that aligned concordantly at least once to <path>
+  (Note: for --un, --al, --un-conc, or --al-conc, add '-gz' to the option name, e.g.
+  --un-gz <path>, to gzip compress output, or add '-bz2' to bzip2 compress output.)
+  --summary-file <path> print alignment summary to this file.
+  --new-summary         print alignment summary in a new style, which is more machine-friendly.
+  --quiet               print nothing to stderr except serious errors
+  --met-file <path>     send metrics to file at <path> (off)
+  --met-stderr          send metrics to stderr (off)
+  --met <int>           report internal counters & metrics every <int> secs (1)
+  --no-head             suppress header lines, i.e. lines starting with @
+  --no-sq               suppress @SQ header lines
+  --rg-id <text>        set read group id, reflected in @RG line and RG:Z: opt field
+  --rg <text>           add <text> ("lab:value") to @RG line of SAM header.
+                        Note: @RG line only printed when --rg-id is set.
+  --omit-sec-seq        put '*' in SEQ and QUAL fields for secondary alignments.
+
+ Performance:
+  -o/--offrate <int> override offrate of index; must be >= index's offrate
+  -p/--threads <int> number of alignment threads to launch (1)
+  --reorder          force SAM output order to match order of input reads
+  --mm               use memory-mapped I/O for index; many 'hisat2's can share
+
+ Other:
+  --qc-filter        filter out reads that are bad according to QSEQ filter
+  --seed <int>       seed for random number generator (0)
+  --non-deterministic seed rand. gen. arbitrarily instead of using read attributes
+  --remove-chrname   remove 'chr' from reference names in alignment
+  --add-chrname      add 'chr' to reference names in alignment 
+  --version          print version information and quit
+  -h/--help          print this usage message
diff --git a/tests/tool_audit/help/kallisto.txt b/tests/tool_audit/help/kallisto.txt
new file mode 100644
index 00000000..c3cc958e
--- /dev/null
+++ b/tests/tool_audit/help/kallisto.txt
@@ -0,0 +1,19 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Error: invalid command --help
+kallisto 0.51.0
+
+Usage: kallisto <CMD> [arguments] ..
+
+Where <CMD> can be one of:
+
+    index         Builds a kallisto index 
+    quant         Runs the quantification algorithm 
+    quant-tcc     Runs quantification on transcript-compatibility counts
+    bus           Generate BUS files for single-cell data 
+    h5dump        Converts HDF5-formatted results to plaintext
+    inspect       Inspects and gives information about an index
+    version       Prints version information
+    cite          Prints citation information
+
+Running kallisto <CMD> without arguments prints usage information for <CMD>
+
diff --git a/tests/tool_audit/help/kallisto_index.txt b/tests/tool_audit/help/kallisto_index.txt
new file mode 100644
index 00000000..c118f9b8
--- /dev/null
+++ b/tests/tool_audit/help/kallisto_index.txt
@@ -0,0 +1,21 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+kallisto 0.51.0
+Builds a kallisto index
+
+Usage: kallisto index [arguments] FASTA-files
+
+Required argument:
+-i, --index=STRING          Filename for the kallisto index to be constructed 
+
+Optional argument:
+-k, --kmer-size=INT         k-mer (odd) length (default: 31, max value: 31)
+-t, --threads=INT           Number of threads to use (default: 1)
+-d, --d-list=STRING         Path to a FASTA-file containing sequences to mask from quantification
+    --make-unique           Replace repeated target names with unique names
+    --aa                    Generate index from a FASTA-file containing amino acid sequences
+    --distinguish           Generate index where sequences are distinguished by the sequence name
+-T, --tmp=STRING            Temporary directory (default: tmp)
+-m, --min-size=INT          Length of minimizers (default: automatically chosen)
+-e, --ec-max-size=INT       Maximum number of targets in an equivalence class (default: no maximum)
+
diff --git a/tests/tool_audit/help/kallisto_quant.txt b/tests/tool_audit/help/kallisto_quant.txt
new file mode 100644
index 00000000..1cf6182c
--- /dev/null
+++ b/tests/tool_audit/help/kallisto_quant.txt
@@ -0,0 +1,30 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+kallisto 0.51.0
+Computes equivalence classes for reads and quantifies abundances
+
+Usage: kallisto quant [arguments] FASTQ-files
+
+Required arguments:
+-i, --index=STRING            Filename for the kallisto index to be used for
+                              quantification
+-o, --output-dir=STRING       Directory to write output to
+
+Optional arguments:
+-b, --bootstrap-samples=INT   Number of bootstrap samples (default: 0)
+    --seed=INT                Seed for the bootstrap sampling (default: 42)
+    --plaintext               Output plaintext instead of HDF5
+    --single                  Quantify single-end reads
+    --single-overhang         Include reads where unobserved rest of fragment is
+                              predicted to lie outside a transcript
+    --fr-stranded             Strand specific reads, first read forward
+    --rf-stranded             Strand specific reads, first read reverse
+-l, --fragment-length=DOUBLE  Estimated average fragment length
+-s, --sd=DOUBLE               Estimated standard deviation of fragment length
+                              (default: -l, -s values are estimated from paired
+                               end data, but are required when using --single)
+-p, --priors                  Priors for the EM algorithm, either as raw counts or as
+                              probabilities. Pseudocounts are added to raw reads to
+                              prevent zero valued priors. Supplied in the same order
+                              as the transcripts in the transcriptome
+-t, --threads=INT             Number of threads to use (default: 1)
+    --verbose                 Print out progress information every 1M proccessed reads
diff --git a/tests/tool_audit/help/macs2.txt b/tests/tool_audit/help/macs2.txt
new file mode 100644
index 00000000..9dd6005f
--- /dev/null
+++ b/tests/tool_audit/help/macs2.txt
@@ -0,0 +1,57 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: macs2 [-h] [--version]
+             {callpeak,bdgpeakcall,bdgbroadcall,bdgcmp,bdgopt,cmbreps,bdgdiff,filterdup,predictd,pileup,randsample,refinepeak}
+             ...
+
+macs2 -- Model-based Analysis for ChIP-Sequencing
+
+positional arguments:
+  {callpeak,bdgpeakcall,bdgbroadcall,bdgcmp,bdgopt,cmbreps,bdgdiff,filterdup,predictd,pileup,randsample,refinepeak}
+    callpeak            Main MACS2 Function: Call peaks from alignment
+                        results.
+    bdgpeakcall         Call peaks from bedGraph output. Note: All regions on
+                        the same chromosome in the bedGraph file should be
+                        continuous so only bedGraph files from MACS2 are
+                        accpetable.
+    bdgbroadcall        Call broad peaks from bedGraph output. Note: All
+                        regions on the same chromosome in the bedGraph file
+                        should be continuous so only bedGraph files from MACS2
+                        are accpetable.
+    bdgcmp              Deduct noise by comparing two signal tracks in
+                        bedGraph. Note: All regions on the same chromosome in
+                        the bedGraph file should be continuous so only
+                        bedGraph files from MACS2 are accpetable.
+    bdgopt              Operations on score column of bedGraph file. Note: All
+                        regions on the same chromosome in the bedGraph file
+                        should be continuous so only bedGraph files from MACS2
+                        are accpetable.
+    cmbreps             Combine BEDGraphs of scores from replicates. Note: All
+                        regions on the same chromosome in the bedGraph file
+                        should be continuous so only bedGraph files from MACS2
+                        are accpetable.
+    bdgdiff             Differential peak detection based on paired four
+                        bedgraph files. Note: All regions on the same
+                        chromosome in the bedGraph file should be continuous
+                        so only bedGraph files from MACS2 are accpetable.
+    filterdup           Remove duplicate reads at the same position, then save
+                        the rest alignments to BED or BEDPE file. If you use '
+                        --keep-dup all option', this script can be utilized to
+                        convert any acceptable format into BED or BEDPE
+                        format.
+    predictd            Predict d or fragment size from alignment results.
+                        *Will NOT filter duplicates*
+    pileup              Pileup aligned reads with a given extension size
+                        (fragment size or d in MACS language). Note there will
+                        be no step for duplicate reads filtering or sequencing
+                        depth scaling, so you may need to do certain pre/post-
+                        processing.
+    randsample          Randomly sample number/percentage of total reads.
+    refinepeak          (Experimental) Take raw reads alignment, refine peak
+                        summits and give scores measuring balance of
+                        waston/crick tags. Inspired by SPP.
+
+options:
+  -h, --help            show this help message and exit
+  --version             show program's version number and exit
+
+For command line options of each command, type: macs2 COMMAND -h
diff --git a/tests/tool_audit/help/macs2_callpeak.txt b/tests/tool_audit/help/macs2_callpeak.txt
new file mode 100644
index 00000000..f6fc6207
--- /dev/null
+++ b/tests/tool_audit/help/macs2_callpeak.txt
@@ -0,0 +1,282 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: macs2 callpeak [-h] -t TFILE [TFILE ...] [-c [CFILE ...]]
+                      [-f {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}]
+                      [-g GSIZE] [-s TSIZE] [--keep-dup KEEPDUPLICATES]
+                      [--outdir OUTDIR] [-n NAME] [-B] [--verbose VERBOSE]
+                      [--trackline] [--SPMR] [--nomodel] [--shift SHIFT]
+                      [--extsize EXTSIZE] [--bw BW] [--d-min D_MIN]
+                      [-m MFOLD MFOLD] [--fix-bimodal] [-q QVALUE | -p PVALUE]
+                      [--scale-to {large,small}] [--down-sample] [--seed SEED]
+                      [--tempdir TEMPDIR] [--nolambda] [--slocal SMALLLOCAL]
+                      [--llocal LARGELOCAL] [--max-gap MAXGAP]
+                      [--min-length MINLEN] [--broad]
+                      [--broad-cutoff BROADCUTOFF] [--cutoff-analysis]
+                      [--call-summits] [--fe-cutoff FECUTOFF]
+                      [--buffer-size BUFFER_SIZE] [--to-large] [--ratio RATIO]
+
+options:
+  -h, --help            show this help message and exit
+
+Input files arguments:
+  -t TFILE [TFILE ...], --treatment TFILE [TFILE ...]
+                        ChIP-seq treatment file. If multiple files are given
+                        as '-t A B C', then they will all be read and pooled
+                        together. REQUIRED.
+  -c [CFILE ...], --control [CFILE ...]
+                        Control file. If multiple files are given as '-c A B
+                        C', they will be pooled to estimate ChIP-seq
+                        background noise.
+  -f {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}, --format {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}
+                        Format of tag file, "AUTO", "BED" or "ELAND" or
+                        "ELANDMULTI" or "ELANDEXPORT" or "SAM" or "BAM" or
+                        "BOWTIE" or "BAMPE" or "BEDPE". The default AUTO
+                        option will let MACS decide which format (except for
+                        BAMPE and BEDPE which should be implicitly set) the
+                        file is. Please check the definition in README. Please
+                        note that if the format is set as BAMPE or BEDPE,
+                        MACS2 will call its special Paired-end mode to call
+                        peaks by piling up the actual ChIPed fragments defined
+                        by both aligned ends, instead of predicting the
+                        fragment size first and extending reads. Also please
+                        note that the BEDPE only contains three columns, and
+                        is NOT the same BEDPE format used by BEDTOOLS.
+                        DEFAULT: "AUTO"
+  -g GSIZE, --gsize GSIZE
+                        Effective genome size. It can be 1.0e+9 or 1000000000,
+                        or shortcuts:'hs' for human (2.7e9), 'mm' for mouse
+                        (1.87e9), 'ce' for C. elegans (9e7) and 'dm' for
+                        fruitfly (1.2e8), Default:hs
+  -s TSIZE, --tsize TSIZE
+                        Tag size/read length. This will override the auto
+                        detected tag size. DEFAULT: Not set
+  --keep-dup KEEPDUPLICATES
+                        It controls the behavior towards duplicate tags at the
+                        exact same location -- the same coordination and the
+                        same strand. The 'auto' option makes MACS calculate
+                        the maximum tags at the exact same location based on
+                        binomal distribution using 1e-5 as pvalue cutoff; and
+                        the 'all' option keeps every tags. If an integer is
+                        given, at most this number of tags will be kept at the
+                        same location. Note, if you've used samtools or picard
+                        to flag reads as 'PCR/Optical duplicate' in bit 1024,
+                        MACS2 will still read them although the reads may be
+                        decided by MACS2 as duplicate later. If you plan to
+                        rely on samtools/picard/any other tool to filter
+                        duplicates, please remove those duplicate reads and
+                        save a new alignment file then ask MACS2 to keep all
+                        by '--keep-dup all'. The default is to keep one tag at
+                        the same location. Default: 1
+
+Output arguments:
+  --outdir OUTDIR       If specified all output files will be written to that
+                        directory. Default: the current working directory
+  -n NAME, --name NAME  Experiment name, which will be used to generate output
+                        file names. DEFAULT: "NA"
+  -B, --bdg             Whether or not to save extended fragment pileup, and
+                        local lambda tracks (two files) at every bp into a
+                        bedGraph file. DEFAULT: False
+  --verbose VERBOSE     Set verbose level of runtime message. 0: only show
+                        critical message, 1: show additional warning message,
+                        2: show process information, 3: show debug messages.
+                        DEFAULT:2
+  --trackline           Tells MACS to include trackline with bedGraph files.
+                        To include this trackline while displaying bedGraph at
+                        UCSC genome browser, can show name and description of
+                        the file as well. However my suggestion is to convert
+                        bedGraph to bigWig, then show the smaller and faster
+                        binary bigWig file at UCSC genome browser, as well as
+                        downstream analysis. Require -B to be set. Default:
+                        Not include trackline.
+  --SPMR                If True, MACS will SAVE signal per million reads for
+                        fragment pileup profiles. It won't interfere with
+                        computing pvalue/qvalue during peak calling, since
+                        internally MACS2 keeps using the raw pileup and
+                        scaling factors between larger and smaller dataset to
+                        calculate statistics measurements. If you plan to use
+                        the signal output in bedGraph to call peaks using
+                        bdgcmp and bdgpeakcall, you shouldn't use this option
+                        because you will end up with different results.
+                        However, this option is recommended for displaying
+                        normalized pileup tracks across many datasets. Require
+                        -B to be set. Default: False
+
+Shifting model arguments:
+  --nomodel             Whether or not to build the shifting model. If True,
+                        MACS will not build model. by default it means
+                        shifting size = 100, try to set extsize to change it.
+                        It's highly recommended that while you have many
+                        datasets to process and you plan to compare different
+                        conditions, aka differential calling, use both
+                        'nomodel' and 'extsize' to make signal files from
+                        different datasets comparable. DEFAULT: False
+  --shift SHIFT         (NOT the legacy --shiftsize option!) The arbitrary
+                        shift in bp. Use discretion while setting it other
+                        than default value. When NOMODEL is set, MACS will use
+                        this value to move cutting ends (5') towards 5'->3'
+                        direction then apply EXTSIZE to extend them to
+                        fragments. When this value is negative, ends will be
+                        moved toward 3'->5' direction. Recommended to keep it
+                        as default 0 for ChIP-Seq datasets, or -1 * half of
+                        EXTSIZE together with EXTSIZE option for detecting
+                        enriched cutting loci such as certain DNAseI-Seq
+                        datasets. Note, you can't set values other than 0 if
+                        format is BAMPE or BEDPE for paired-end data. DEFAULT:
+                        0.
+  --extsize EXTSIZE     The arbitrary extension size in bp. When nomodel is
+                        true, MACS will use this value as fragment size to
+                        extend each read towards 3' end, then pile them up.
+                        It's exactly twice the number of obsolete SHIFTSIZE.
+                        In previous language, each read is moved 5'->3'
+                        direction to middle of fragment by 1/2 d, then
+                        extended to both direction with 1/2 d. This is
+                        equivalent to say each read is extended towards 5'->3'
+                        into a d size fragment. DEFAULT: 200. EXTSIZE and
+                        SHIFT can be combined when necessary. Check SHIFT
+                        option.
+  --bw BW               Band width for picking regions to compute fragment
+                        size. This value is only used while building the
+                        shifting model. Tweaking this is not recommended.
+                        DEFAULT: 300
+  --d-min D_MIN         Minimum fragment size in basepair. Any predicted
+                        fragment size less than this will be excluded.
+                        DEFAULT: 20
+  -m MFOLD MFOLD, --mfold MFOLD MFOLD
+                        Select the regions within MFOLD range of high-
+                        confidence enrichment ratio against background to
+                        build model. Fold-enrichment in regions must be lower
+                        than upper limit, and higher than the lower limit. Use
+                        as "-m 10 30". This setting is only used while
+                        building the shifting model. Tweaking it is not
+                        recommended. DEFAULT:5 50
+  --fix-bimodal         Whether turn on the auto pair model process. If set,
+                        when MACS failed to build paired model, it will use
+                        the nomodel settings, the --exsize parameter to extend
+                        each tags towards 3' direction. Not to use this
+                        automate fixation is a default behavior now. DEFAULT:
+                        False
+
+Peak calling arguments:
+  -q QVALUE, --qvalue QVALUE
+                        Minimum FDR (q-value) cutoff for peak detection.
+                        DEFAULT: 0.05. -q, and -p are mutually exclusive.
+  -p PVALUE, --pvalue PVALUE
+                        Pvalue cutoff for peak detection. DEFAULT: not set.
+                        -q, and -p are mutually exclusive. If pvalue cutoff is
+                        set, qvalue will not be calculated and reported as -1
+                        in the final .xls file.
+  --scale-to {large,small}
+                        When set to 'small', scale the larger sample up to the
+                        smaller sample. When set to 'larger', scale the
+                        smaller sample up to the bigger sample. By default,
+                        scale to 'small'. This option replaces the obsolete '
+                        --to-large' option. The default behavior is
+                        recommended since it will lead to less significant
+                        p/q-values in general but more specific results. Keep
+                        in mind that scaling down will influence control/input
+                        sample more. DEFAULT: 'small', the choice is either
+                        'small' or 'large'.
+  --down-sample         When set, random sampling method will scale down the
+                        bigger sample. By default, MACS uses linear scaling.
+                        Warning: This option will make your result unstable
+                        and irreproducible since each time, random reads would
+                        be selected. Consider to use 'randsample' script
+                        instead. <not implmented>If used together with --SPMR,
+                        1 million unique reads will be randomly picked.</not
+                        implemented> Caution: due to the implementation, the
+                        final number of selected reads may not be as you
+                        expected! DEFAULT: False
+  --seed SEED           Set the random seed while down sampling data. Must be
+                        a non-negative integer in order to be effective.
+                        DEFAULT: not set
+  --tempdir TEMPDIR     Optional directory to store temp files. DEFAULT: /tmp
+  --nolambda            If True, MACS will use fixed background lambda as
+                        local lambda for every peak region. Normally, MACS
+                        calculates a dynamic local lambda to reflect the local
+                        bias due to the potential chromatin accessibility.
+  --slocal SMALLLOCAL   The small nearby region in basepairs to calculate
+                        dynamic lambda. This is used to capture the bias near
+                        the peak summit region. Invalid if there is no control
+                        data. If you set this to 0, MACS will skip slocal
+                        lambda calculation. *Note* that MACS will always
+                        perform a d-size local lambda calculation while the
+                        control data is available. The final local bias would
+                        be the maximum of the lambda value from d, slocal, and
+                        llocal size windows. While control is not available, d
+                        and slocal lambda won't be considered. DEFAULT: 1000
+  --llocal LARGELOCAL   The large nearby region in basepairs to calculate
+                        dynamic lambda. This is used to capture the surround
+                        bias. If you set this to 0, MACS will skip llocal
+                        lambda calculation. *Note* that MACS will always
+                        perform a d-size local lambda calculation while the
+                        control data is available. The final local bias would
+                        be the maximum of the lambda value from d, slocal, and
+                        llocal size windows. While control is not available, d
+                        and slocal lambda won't be considered. DEFAULT: 10000.
+  --max-gap MAXGAP      Maximum gap between significant sites to cluster them
+                        together. The DEFAULT value is the detected read
+                        length/tag size.
+  --min-length MINLEN   Minimum length of a peak. The DEFAULT value is the
+                        predicted fragment size d. Note, if you set a value
+                        smaller than the fragment size, it may have NO effect
+                        on the result. For BROAD peak calling, try to set a
+                        large value such as 500bps. You can also use '--
+                        cutoff-analysis' option with default setting, and
+                        check the column 'avelpeak' under different cutoff
+                        values to decide a reasonable minlen value.
+  --broad               If set, MACS will try to call broad peaks using the
+                        --broad-cutoff setting. Please tweak '--broad-cutoff'
+                        setting to control the peak calling behavior. At the
+                        meantime, either -q or -p cutoff will be used to
+                        define regions with 'stronger enrichment' inside of
+                        broad peaks. The maximum gap is expanded to 4 * MAXGAP
+                        (--max-gap parameter). As a result, MACS will output a
+                        'gappedPeak' and a 'broadPeak' file instead of
+                        'narrowPeak' file. Note, a broad peak will be reported
+                        even if there is no 'stronger enrichment' inside.
+                        DEFAULT: False
+  --broad-cutoff BROADCUTOFF
+                        Cutoff for broad region. This option is not available
+                        unless --broad is set. If -p is set, this is a pvalue
+                        cutoff, otherwise, it's a qvalue cutoff. Please note
+                        that in broad peakcalling mode, MACS2 uses this
+                        setting to control the overall peak calling behavior,
+                        then uses -q or -p setting to define regions inside
+                        broad region as 'stronger' enrichment. DEFAULT: 0.1
+  --cutoff-analysis     While set, MACS2 will analyze number or total length
+                        of peaks that can be called by different p-value
+                        cutoff then output a summary table to help user decide
+                        a better cutoff. The table will be saved in
+                        NAME_cutoff_analysis.txt file. Note, minlen and maxgap
+                        may affect the results. WARNING: May take ~30 folds
+                        longer time to finish. The result can be useful for
+                        users to decide a reasonable cutoff value. DEFAULT:
+                        False
+
+Post-processing options:
+  --call-summits        If set, MACS will use a more sophisticated signal
+                        processing approach to find subpeak summits in each
+                        enriched peak region. DEFAULT: False
+  --fe-cutoff FECUTOFF  When set, the value will be used to filter out peaks
+                        with low fold-enrichment. Note, MACS2 use 1.0 as
+                        pseudocount while calculating fold-enrichment.
+                        DEFAULT: 1.0
+
+Other options:
+  --buffer-size BUFFER_SIZE
+                        Buffer size for incrementally increasing internal
+                        array size to store reads alignment information. In
+                        most cases, you don't have to change this parameter.
+                        However, if there are large number of
+                        chromosomes/contigs/scaffolds in your alignment, it's
+                        recommended to specify a smaller buffer size in order
+                        to decrease memory usage (but it will take longer time
+                        to read alignment files). Minimum memory requested for
+                        reading an alignment file is about # of CHROMOSOME *
+                        BUFFER_SIZE * 8 Bytes. DEFAULT: 100000
+
+Obsolete options:
+  --to-large            Obsolete option. Please use '--scale-to large'
+                        instead.
+  --ratio RATIO         Obsolete option. Originally designed to normalize
+                        treatment and control with customized ratio, now it
+                        won't have any effect.
diff --git a/tests/tool_audit/help/macs3.txt b/tests/tool_audit/help/macs3.txt
new file mode 100644
index 00000000..9f8d6415
--- /dev/null
+++ b/tests/tool_audit/help/macs3.txt
@@ -0,0 +1,39 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: macs3 [-h] [--version]
+             {callpeak,bdgpeakcall,bdgbroadcall,bdgcmp,bdgopt,cmbreps,bdgdiff,filterdup,predictd,pileup,randsample,refinepeak,callvar,hmmratac}
+             ...
+
+macs3 -- Model-based Analysis for ChIP-Sequencing
+
+positional arguments:
+  {callpeak,bdgpeakcall,bdgbroadcall,bdgcmp,bdgopt,cmbreps,bdgdiff,filterdup,predictd,pileup,randsample,refinepeak,callvar,hmmratac}
+    callpeak            Main MACS3 Function: Call peaks from alignment
+                        results.
+    bdgpeakcall         Call peaks from bedGraph file.
+    bdgbroadcall        Call nested broad peaks from bedGraph file.
+    bdgcmp              Comparing two signal tracks in bedGraph format.
+    bdgopt              Operate the score column of bedGraph file.
+    cmbreps             Combine bedGraph files of scores from replicates.
+    bdgdiff             Differential peak detection based on paired four
+                        bedGraph files.
+    filterdup           Remove duplicate reads, then save in BED/BEDPE format
+                        file.
+    predictd            Predict d or fragment size from alignment results. In
+                        case of PE data, report the average insertion/fragment
+                        size from all pairs.
+    pileup              Pileup aligned reads (single-end) or fragments
+                        (paired-end).
+    randsample          Randomly choose a number/percentage of total reads,
+                        then save in BED/BEDPE format file.
+    refinepeak          Take raw reads alignment, refine peak summits.
+                        Inspired by SPP.
+    callvar             Call variants in given peak regions from the alignment
+                        BAM files.
+    hmmratac            Dedicated peak calling based on Hidden Markov Model
+                        for ATAC-seq data.
+
+options:
+  -h, --help            show this help message and exit
+  --version             show program's version number and exit
+
+For command line options of each command, type: macs3 COMMAND -h
diff --git a/tests/tool_audit/help/macs3_callpeak.txt b/tests/tool_audit/help/macs3_callpeak.txt
new file mode 100644
index 00000000..90186e1f
--- /dev/null
+++ b/tests/tool_audit/help/macs3_callpeak.txt
@@ -0,0 +1,300 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: macs3 callpeak [-h] -t TFILE [TFILE ...] [-c [CFILE ...]]
+                      [-f {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}]
+                      [-g GSIZE] [-s TSIZE] [--keep-dup KEEPDUPLICATES]
+                      [--outdir OUTDIR] [-n NAME] [-B] [--verbose VERBOSE]
+                      [--trackline] [--SPMR] [--nomodel] [--shift SHIFT]
+                      [--extsize EXTSIZE] [--bw BW] [--d-min D_MIN]
+                      [-m MFOLD MFOLD] [--fix-bimodal] [-q QVALUE | -p PVALUE]
+                      [--scale-to {large,small}] [--down-sample] [--seed SEED]
+                      [--tempdir TEMPDIR] [--nolambda] [--slocal SMALLLOCAL]
+                      [--llocal LARGELOCAL] [--max-gap MAXGAP]
+                      [--min-length MINLEN] [--broad]
+                      [--broad-cutoff BROADCUTOFF] [--cutoff-analysis]
+                      [--call-summits] [--fe-cutoff FECUTOFF] [--to-large]
+                      [--ratio RATIO] [--buffer-size BUFFER_SIZE]
+
+options:
+  -h, --help            show this help message and exit
+
+Input files arguments:
+  -t TFILE [TFILE ...], --treatment TFILE [TFILE ...]
+                        ChIP-seq treatment file. If multiple files are given
+                        as '-t A B C', then they will all be read and pooled
+                        together. REQUIRED.
+  -c [CFILE ...], --control [CFILE ...]
+                        Control file. If multiple files are given as '-c A B
+                        C', they will be pooled to estimate ChIP-seq
+                        background noise.
+  -f {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}, --format {AUTO,BAM,SAM,BED,ELAND,ELANDMULTI,ELANDEXPORT,BOWTIE,BAMPE,BEDPE}
+                        Format of tag file, "AUTO", "BED" or "ELAND" or
+                        "ELANDMULTI" or "ELANDEXPORT" or "SAM" or "BAM" or
+                        "BOWTIE" or "BAMPE" or "BEDPE". The default AUTO
+                        option will let MACS decide which format (except for
+                        BAMPE and BEDPE which should be implicitly set) the
+                        file is. Please check the definition in README. Please
+                        note that if the format is set as BAMPE or BEDPE,
+                        MACS3 will call its special Paired-end mode to call
+                        peaks by piling up the actual ChIPed fragments defined
+                        by both aligned ends, instead of predicting the
+                        fragment size first and extending reads. Also please
+                        note that the BEDPE only contains three columns, and
+                        is NOT the same BEDPE format used by BEDTOOLS.
+                        DEFAULT: "AUTO"
+  -g GSIZE, --gsize GSIZE
+                        Effective genome size. It can be 1.0e+9 or 1000000000,
+                        or shortcuts:'hs' for human (2,913,022,398), 'mm' for
+                        mouse (2,652,783,500), 'ce' for C. elegans
+                        (100,286,401) and 'dm' for fruitfly (142,573,017),
+                        Default:hs. The effective genome size numbers for the
+                        above four species are collected from Deeptools https:
+                        //deeptools.readthedocs.io/en/develop/content/feature/
+                        effectiveGenomeSize.html Please refer to deeptools to
+                        define the best genome size you plan to use.
+  -s TSIZE, --tsize TSIZE
+                        Tag size/read length. This will override the auto
+                        detected tag size. DEFAULT: Not set
+  --keep-dup KEEPDUPLICATES
+                        It controls the behavior towards duplicate tags at the
+                        exact same location -- the same coordination and the
+                        same strand. The 'auto' option makes MACS calculate
+                        the maximum tags at the exact same location based on
+                        binomal distribution using 1e-5 as pvalue cutoff; and
+                        the 'all' option keeps every tags. If an integer is
+                        given, at most this number of tags will be kept at the
+                        same location. Note, if you've used samtools or picard
+                        to flag reads as 'PCR/Optical duplicate' in bit 1024,
+                        MACS3 will still read them although the reads may be
+                        decided by MACS3 as duplicate later. If you plan to
+                        rely on samtools/picard/any other tool to filter
+                        duplicates, please remove those duplicate reads and
+                        save a new alignment file then ask MACS3 to keep all
+                        by '--keep-dup all'. The default is to keep one tag at
+                        the same location. Default: 1
+
+Output arguments:
+  --outdir OUTDIR       If specified all output files will be written to that
+                        directory. Default: the current working directory
+  -n NAME, --name NAME  Experiment name, which will be used to generate output
+                        file names. DEFAULT: "NA"
+  -B, --bdg             Whether or not to save extended fragment pileup, and
+                        local lambda tracks (two files) at every bp into a
+                        bedGraph file. DEFAULT: False
+  --verbose VERBOSE     Set verbose level of runtime message. 0: only show
+                        critical message, 1: show additional warning message,
+                        2: show process information, 3: show debug messages.
+                        DEFAULT:2
+  --trackline           Instruct MACS to include trackline in the header of
+                        output files, including the bedGraph, narrowPeak,
+                        gappedPeak, BED format files. To include this
+                        trackline is necessary while uploading them to the
+                        UCSC genome browser. You can also mannually add these
+                        trackline to corresponding output files. For example,
+                        in order to upload narrowPeak file to UCSC browser,
+                        add this to as the first line -- `track
+                        type=narrowPeak name="my_peaks" description="my
+                        peaks"`. Default: Not to include trackline.
+  --SPMR                If True, MACS will SAVE signal per million reads for
+                        fragment pileup profiles. It won't interfere with
+                        computing pvalue/qvalue during peak calling, since
+                        internally MACS3 keeps using the raw pileup and
+                        scaling factors between larger and smaller dataset to
+                        calculate statistics measurements. If you plan to use
+                        the signal output in bedGraph to call peaks using
+                        bdgcmp and bdgpeakcall, you shouldn't use this option
+                        because you will end up with different results.
+                        However, this option is recommended for displaying
+                        normalized pileup tracks across many datasets. Require
+                        -B to be set. Default: False
+
+Shifting model arguments:
+  --nomodel             Whether or not to build the shifting model. If True,
+                        MACS will not build model. by default it means
+                        shifting size = 100, try to set extsize to change it.
+                        It's highly recommended that while you have many
+                        datasets to process and you plan to compare different
+                        conditions, aka differential calling, use both
+                        'nomodel' and 'extsize' to make signal files from
+                        different datasets comparable. DEFAULT: False
+  --shift SHIFT         (NOT the legacy --shiftsize option!) The arbitrary
+                        shift in bp. Use discretion while setting it other
+                        than default value. When NOMODEL is set, MACS will use
+                        this value to move cutting ends (5') towards 5'->3'
+                        direction then apply EXTSIZE to extend them to
+                        fragments. When this value is negative, ends will be
+                        moved toward 3'->5' direction. Recommended to keep it
+                        as default 0 for ChIP-Seq datasets, or -1 * half of
+                        EXTSIZE together with EXTSIZE option for detecting
+                        enriched cutting loci such as certain DNAseI-Seq
+                        datasets. Note, you can't set values other than 0 if
+                        format is BAMPE or BEDPE for paired-end data. DEFAULT:
+                        0.
+  --extsize EXTSIZE     The arbitrary extension size in bp. When nomodel is
+                        true, MACS will use this value as fragment size to
+                        extend each read towards 3' end, then pile them up.
+                        It's exactly twice the number of obsolete SHIFTSIZE.
+                        In previous language, each read is moved 5'->3'
+                        direction to middle of fragment by 1/2 d, then
+                        extended to both direction with 1/2 d. This is
+                        equivalent to say each read is extended towards 5'->3'
+                        into a d size fragment. DEFAULT: 200. EXTSIZE and
+                        SHIFT can be combined when necessary. Check SHIFT
+                        option.
+  --bw BW               Band width for picking regions to compute fragment
+                        size. This value is only used while building the
+                        shifting model. Tweaking this is not recommended.
+                        DEFAULT: 300
+  --d-min D_MIN         Minimum fragment size in basepair. Any predicted
+                        fragment size less than this will be excluded.
+                        DEFAULT: 20
+  -m MFOLD MFOLD, --mfold MFOLD MFOLD
+                        Select the regions within MFOLD range of high-
+                        confidence enrichment ratio against background to
+                        build model. Fold-enrichment in regions must be lower
+                        than upper limit, and higher than the lower limit. Use
+                        as "-m 10 30". This setting is only used while
+                        building the shifting model. Tweaking it is not
+                        recommended. DEFAULT:5 50
+  --fix-bimodal         Whether turn on the auto pair model process. If set,
+                        when MACS failed to build paired model, it will use
+                        the nomodel settings, the --exsize parameter to extend
+                        each tags towards 3' direction. Not to use this
+                        automate fixation is a default behavior now. DEFAULT:
+                        False
+
+Peak calling arguments:
+  -q QVALUE, --qvalue QVALUE
+                        Minimum FDR (q-value) cutoff for peak detection.
+                        DEFAULT: 0.05. -q, and -p are mutually exclusive.
+  -p PVALUE, --pvalue PVALUE
+                        Pvalue cutoff for peak detection. DEFAULT: not set.
+                        -q, and -p are mutually exclusive. If pvalue cutoff is
+                        set, qvalue will not be calculated and reported as -1
+                        in the final .xls file.
+  --scale-to {large,small}
+                        When set to 'small', scale the larger sample up to the
+                        smaller sample. When set to 'larger', scale the
+                        smaller sample up to the bigger sample. By default,
+                        scale to 'small'. This option replaces the obsolete '
+                        --to-large' option. The default behavior is
+                        recommended since it will lead to less significant
+                        p/q-values in general but more specific results. Keep
+                        in mind that scaling down will influence control/input
+                        sample more. DEFAULT: 'small', the choice is either
+                        'small' or 'large'.
+  --down-sample         When set, random sampling method will scale down the
+                        bigger sample. By default, MACS uses linear scaling.
+                        Warning: This option will make your result unstable
+                        and irreproducible since each time, random reads would
+                        be selected. Consider to use 'randsample' script
+                        instead. <not implmented>If used together with --SPMR,
+                        1 million unique reads will be randomly picked.</not
+                        implemented> Caution: due to the implementation, the
+                        final number of selected reads may not be as you
+                        expected! DEFAULT: False
+  --seed SEED           Set the random seed while down sampling data. Must be
+                        a non-negative integer in order to be effective.
+                        DEFAULT: not set
+  --tempdir TEMPDIR     Optional directory to store temp files. DEFAULT: /tmp
+  --nolambda            If True, MACS will use fixed background lambda as
+                        local lambda for every peak region. Normally, MACS
+                        calculates a dynamic local lambda to reflect the local
+                        bias due to the potential chromatin accessibility.
+  --slocal SMALLLOCAL   The small nearby region in basepairs to calculate
+                        dynamic lambda. This is used to capture the bias near
+                        the peak summit region. Invalid if there is no control
+                        data. If you set this to 0, MACS will skip slocal
+                        lambda calculation. *Note* that MACS will always
+                        perform a d-size local lambda calculation while the
+                        control data is available. The final local bias would
+                        be the maximum of the lambda value from d, slocal, and
+                        llocal size windows. While control is not available, d
+                        and slocal lambda won't be considered. DEFAULT: 1000
+  --llocal LARGELOCAL   The large nearby region in basepairs to calculate
+                        dynamic lambda. This is used to capture the surround
+                        bias. If you set this to 0, MACS will skip llocal
+                        lambda calculation. *Note* that MACS will always
+                        perform a d-size local lambda calculation while the
+                        control data is available. The final local bias would
+                        be the maximum of the lambda value from d, slocal, and
+                        llocal size windows. While control is not available, d
+                        and slocal lambda won't be considered. DEFAULT: 10000.
+  --max-gap MAXGAP      Maximum gap between significant sites to cluster them
+                        together. The DEFAULT value is the detected read
+                        length/tag size.
+  --min-length MINLEN   Minimum length of a peak. The DEFAULT value is the
+                        predicted fragment size d. Note, if you set a value
+                        smaller than the fragment size, it may have NO effect
+                        on the result. For BROAD peak calling, try to set a
+                        large value such as 500bps. You can also use '--
+                        cutoff-analysis' option with default setting, and
+                        check the column 'avelpeak' under different cutoff
+                        values to decide a reasonable minlen value.
+  --broad               If set, MACS will try to call broad peaks using the
+                        --broad-cutoff setting. Please tweak '--broad-cutoff'
+                        setting to control the peak calling behavior. At the
+                        meantime, either -q or -p cutoff will be used to
+                        define regions with 'stronger enrichment' inside of
+                        broad peaks. The maximum gap is expanded to 4 * MAXGAP
+                        (--max-gap parameter). As a result, MACS will output a
+                        'gappedPeak' and a 'broadPeak' file instead of
+                        'narrowPeak' file. Note, a broad peak will be reported
+                        even if there is no 'stronger enrichment' inside.
+                        DEFAULT: False
+  --broad-cutoff BROADCUTOFF
+                        Cutoff for broad region. This option is not available
+                        unless --broad is set. If -p is set, this is a pvalue
+                        cutoff, otherwise, it's a qvalue cutoff. Please note
+                        that in broad peakcalling mode, MACS3 uses this
+                        setting to control the overall peak calling behavior,
+                        then uses -q or -p setting to define regions inside
+                        broad region as 'stronger' enrichment. DEFAULT: 0.1
+  --cutoff-analysis     While set, MACS3 will analyze number or total length
+                        of peaks that can be called by different p-value
+                        cutoff then output a summary table to help user decide
+                        a better cutoff. The table will be saved in
+                        NAME_cutoff_analysis.txt file. Note, minlen and maxgap
+                        may affect the results. WARNING: May take ~30 folds
+                        longer time to finish. The result can be useful for
+                        users to decide a reasonable cutoff value. DEFAULT:
+                        False
+
+Post-processing options:
+  --call-summits        If set, MACS will use a more sophisticated signal
+                        processing approach to find subpeak summits in each
+                        enriched peak region. DEFAULT: False
+  --fe-cutoff FECUTOFF  When set, the value will be used as the minimum
+                        requirement to filter out peaks with low fold-
+                        enrichment. Note, MACS3 adds one as pseudocount while
+                        calculating fold-enrichment. By default, it is set as
+                        1 so there is no filtering. DEFAULT: 1.0
+
+Obsolete options:
+  --to-large            Obsolete option. Please use '--scale-to large'
+                        instead.
+  --ratio RATIO         Obsolete option. Originally designed to normalize
+                        treatment and control with customized ratio, now it
+                        won't have any effect.
+
+Other options:
+  --buffer-size BUFFER_SIZE
+                        Buffer size for incrementally increasing internal
+                        array size to store reads alignment information. In
+                        most cases, you don't have to change this parameter.
+                        However, if there are large number of
+                        chromosomes/contigs/scaffolds in your alignment, it's
+                        recommended to specify a smaller buffer size in order
+                        to decrease memory usage (but it will take longer time
+                        to read alignment files). Minimum memory requested for
+                        reading an alignment file is about # of CHROMOSOME *
+                        BUFFER_SIZE * 8 Bytes. DEFAULT: 100000
+
+Examples:
+1. Peak calling for regular TF ChIP-seq:
+    $ macs3 callpeak -t ChIP.bam -c Control.bam -f BAM -g hs -n test -B -q 0.01
+2. Broad peak calling on Histone Mark ChIP-seq:
+    $ macs3 callpeak -t ChIP.bam -c Control.bam --broad -g hs --broad-cutoff 0.1
+3. Peak calling on ATAC-seq (paired-end mode):
+    $ macs3 callpeak -f BAMPE -t ATAC.bam -g hs -n test -B -q 0.01
+4. Peak calling on ATAC-seq ( focusing on insertion sites, and using single-end mode):
+    $ macs3 callpeak -f BAM -t ATAC.bam -g hs -n test -B -q 0.01 --shift -50 --extension 100
diff --git a/tests/tool_audit/help/minimap2_help.txt b/tests/tool_audit/help/minimap2_help.txt
new file mode 100644
index 00000000..7fc9be58
--- /dev/null
+++ b/tests/tool_audit/help/minimap2_help.txt
@@ -0,0 +1,56 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Usage: minimap2 [options] <target.fa>|<target.idx> [query.fa] [...]
+Options:
+  Indexing:
+    -H           use homopolymer-compressed k-mer (preferrable for PacBio)
+    -k INT       k-mer size (no larger than 28) [15]
+    -w INT       minimizer window size [10]
+    -I NUM       split index for every ~NUM input bases [8G]
+    -d FILE      dump index to FILE []
+  Mapping:
+    -f FLOAT     filter out top FLOAT fraction of repetitive minimizers [0.0002]
+    -g NUM       stop chain enlongation if there are no minimizers in INT-bp [5000]
+    -G NUM       max intron length (effective with -xsplice; changing -r) [200k]
+    -F NUM       max fragment length (effective with -xsr or in the fragment mode) [800]
+    -r NUM[,NUM] chaining/alignment bandwidth and long-join bandwidth [500,20000]
+    -n INT       minimal number of minimizers on a chain [3]
+    -m INT       minimal chaining score (matching bases minus log gap penalty) [40]
+    -X           skip self and dual mappings (for the all-vs-all mode)
+    -p FLOAT     min secondary-to-primary score ratio [0.8]
+    -N INT       retain at most INT secondary alignments [5]
+  Alignment:
+    -A INT       matching score [2]
+    -B INT       mismatch penalty (larger value for lower divergence) [4]
+    -O INT[,INT] gap open penalty [4,24]
+    -E INT[,INT] gap extension penalty; a k-long gap costs min{O1+k*E1,O2+k*E2} [2,1]
+    -z INT[,INT] Z-drop score and inversion Z-drop score [400,200]
+    -s INT       minimal peak DP alignment score [80]
+    -u CHAR      how to find GT-AG. f:transcript strand, b:both strands, n:don't match GT-AG [n]
+    -J INT       splice mode. 0: original minimap2 model; 1: miniprot model [1]
+    -j FILE      junctions in BED12 to extend *short* RNA-seq alignment []
+  Input/Output:
+    -a           output in the SAM format (PAF by default)
+    -o FILE      output alignments to FILE [stdout]
+    -L           write CIGAR with >65535 ops at the CG tag
+    -R STR       SAM read group line in a format like '@RG\tID:foo\tSM:bar' []
+    -c           output CIGAR in PAF
+    --cs[=STR]   output the cs tag; STR is 'short' (if absent) or 'long' [none]
+    --ds         output the ds tag, which is an extension to cs
+    --MD         output the MD tag
+    --eqx        write =/X CIGAR operators
+    -Y           use soft clipping for supplementary alignments
+    -y           copy FASTA/Q comments to output SAM
+    -t INT       number of threads [3]
+    -K NUM       minibatch size for mapping [500M]
+    --version    show version number
+  Preset:
+    -x STR       preset (always applied before other options; see minimap2.1 for details) []
+                 - lr:hq - accurate long reads (error rate <1%) against a reference genome
+                 - splice/splice:hq - spliced alignment for long reads/accurate long reads
+                 - splice:sr - spliced alignment for short RNA-seq reads
+                 - asm5/asm10/asm20 - asm-to-ref mapping, for ~0.1/1/5% sequence divergence
+                 - sr - short reads against a reference
+                 - map-pb/map-hifi/map-ont/map-iclr - CLR/HiFi/Nanopore/ICLR vs reference mapping
+                 - ava-pb/ava-ont - PacBio CLR/Nanopore read overlap
+
+See `man ./minimap2.1' for detailed description of these and other advanced command-line options.
diff --git a/tests/tool_audit/help/picard_markdup.txt b/tests/tool_audit/help/picard_markdup.txt
new file mode 100644
index 00000000..9860df89
--- /dev/null
+++ b/tests/tool_audit/help/picard_markdup.txt
@@ -0,0 +1,278 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+/opt/conda/envs/monsda/bin/picard: line 5: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8): No such file or directory
+USAGE: MarkDuplicates [arguments]
+
+Identifies duplicate reads.  <p>This tool locates and tags duplicate reads in a SAM, BAM or CRAM file, where duplicate
+reads are defined as originating from a single fragment of DNA.  Duplicates can arise during sample preparation e.g.
+library construction using PCR.  See also <a
+href='https://broadinstitute.github.io/picard/command-line-overview.html#EstimateLibraryComplexity'>EstimateLibraryComplexity</a>
+for additional notes on PCR duplication artifacts.  Duplicate reads can also result from a single amplification cluster,
+incorrectly detected as multiple clusters by the optical sensor of the sequencing instrument.  These duplication
+artifacts are referred to as optical duplicates.</p><p>The MarkDuplicates tool works by comparing sequences in the 5
+prime positions of both reads and read-pairs in a SAM/BAM file.  A BARCODE_TAG option is available to facilitate
+duplicate marking using molecular barcodes.  After duplicate reads are collected, the tool differentiates the primary
+and duplicate reads using an algorithm that ranks reads by the sums of their base-quality scores (default method). Note
+that this is different from directly checking if the sequences match, which MarkDuplicates does not do.</p>  <p>The
+tool's main output is a new SAM, BAM or CRAM file, in which duplicates have been identified in the SAM flags field for
+each read.  Duplicates are marked with the hexadecimal value of 0x0400, which corresponds to a decimal value of 1024. 
+If you are not familiar with this type of annotation, please see the following <a
+href='https://www.broadinstitute.org/gatk/blog?id=7019'>blog post</a> for additional information.</p><p>Although the
+bitwise flag annotation indicates whether a read was marked as a duplicate, it does not identify the type of duplicate. 
+To do this, a new tag called the duplicate type (DT) tag was recently added as an optional output in  the 'optional
+field' section of a SAM/BAM/CRAM file.  Invoking the TAGGING_POLICY option, you can instruct the program to mark all the
+duplicates (All), only the optical duplicates (OpticalOnly), or no duplicates (DontTag).  The records within the output
+of a SAM/BAM/CRAM file will have values for the 'DT' tag (depending on the invoked TAGGING_POLICY), as either
+library/PCR-generated duplicates (LB), or sequencing-platform artifact duplicates (SQ).  This tool uses the
+READ_NAME_REGEX and the OPTICAL_DUPLICATE_PIXEL_DISTANCE options as the primary methods to identify and differentiate
+duplicate types.  Set READ_NAME_REGEX to null to skip optical duplicate detection, e.g. for RNA-seq or other data where
+duplicate sets are extremely large and estimating library complexity is not an aim.  Note that without optical duplicate
+counts, library size estimation will be inaccurate.</p> <p>MarkDuplicates also produces a metrics file indicating the
+numbers of duplicates for both single- and paired-end reads.</p>  <p>The program can take either coordinate-sorted or
+query-sorted inputs, however the behavior is slightly different.  When the input is coordinate-sorted, unmapped mates of
+mapped records and supplementary/secondary alignments are not marked as duplicates.  However, when the input is
+query-sorted (actually query-grouped), then unmapped mates and secondary/supplementary reads are not excluded from the
+duplication test and can be marked as duplicate reads.</p>  <p>If desired, duplicates can be removed using the
+REMOVE_DUPLICATE and REMOVE_SEQUENCING_DUPLICATES options.</p><h4>Usage example:</h4><pre>java -jar picard.jar
+MarkDuplicates \<br />      I=input.bam \<br />      O=marked_duplicates.bam \<br />     
+M=marked_dup_metrics.txt</pre>Please see <a
+href='http://broadinstitute.github.io/picard/picard-metric-definitions.html#DuplicationMetrics'>MarkDuplicates</a> for
+detailed explanations of the output metrics.<hr />
+Version:2.27.4-SNAPSHOT
+
+
+Required Arguments:
+
+--INPUT,-I <String>           One or more input SAM, BAM or CRAM files to analyze. Must be coordinate sorted.  This
+                              argument must be specified at least once. Required. 
+
+--METRICS_FILE,-M <File>      File to write duplication metrics to  Required. 
+
+--OUTPUT,-O <File>            The output file to write marked records to  Required. 
+
+
+Optional Arguments:
+
+--ADD_PG_TAG_TO_READS <Boolean>
+                              Add PG tag to each read in a SAM or BAM  Default value: true. Possible values: {true,
+                              false} 
+
+--arguments_file <File>       read one or more arguments files and add them to the command line  This argument may be
+                              specified 0 or more times. Default value: null. 
+
+--ASSUME_SORT_ORDER,-ASO <SortOrder>
+                              If not null, assume that the input file has this order even if the header says otherwise. 
+                              Default value: null. Possible values: {unsorted, queryname, coordinate, duplicate,
+                              unknown}  Cannot be used in conjunction with argument(s) ASSUME_SORTED (AS)
+
+--ASSUME_SORTED,-AS <Boolean> If true, assume that the input file is coordinate sorted even if the header says
+                              otherwise. Deprecated, used ASSUME_SORT_ORDER=coordinate instead.  Default value: false.
+                              Possible values: {true, false}  Cannot be used in conjunction with argument(s)
+                              ASSUME_SORT_ORDER (ASO)
+
+--BARCODE_TAG <String>        Barcode SAM tag (ex. BC for 10X Genomics)  Default value: null. 
+
+--CLEAR_DT <Boolean>          Clear DT tag from input SAM records. Should be set to false if input SAM doesn't have this
+                              tag.  Default true  Default value: true. Possible values: {true, false} 
+
+--COMMENT,-CO <String>        Comment(s) to include in the output file's header.  This argument may be specified 0 or
+                              more times. Default value: null. 
+
+--COMPRESSION_LEVEL <Integer> Compression level for all compressed files created (e.g. BAM and VCF).  Default value: 5. 
+
+--CREATE_INDEX <Boolean>      Whether to create an index when writing VCF or coordinate sorted BAM output.  Default
+                              value: false. Possible values: {true, false} 
+
+--CREATE_MD5_FILE <Boolean>   Whether to create an MD5 digest for any BAM or FASTQ files created.    Default value:
+                              false. Possible values: {true, false} 
+
+--DUPLEX_UMI <Boolean>        Treat UMIs as being duplex stranded.  This option requires that the UMI consist of two
+                              equal length strings that are separated by a hyphen (e.g. 'ATC-GTC'). Reads are considered
+                              duplicates if, in addition to standard definition, have identical normalized UMIs.  A UMI
+                              from the 'bottom' strand is normalized by swapping its content around the hyphen (eg.
+                              ATC-GTC becomes GTC-ATC).  A UMI from the 'top' strand is already normalized as it is.
+                              Both reads from a read pair considered top strand if the read 1 unclipped 5' coordinate is
+                              less than the read 2 unclipped 5' coordinate. All chimeric reads and read fragments are
+                              treated as having come from the top strand. With this option is it required that the
+                              BARCODE_TAG hold non-normalized UMIs. Default false.  Default value: false. Possible
+                              values: {true, false} 
+
+--DUPLICATE_SCORING_STRATEGY,-DS <ScoringStrategy>
+                              The scoring strategy for choosing the non-duplicate among candidates.  Default value:
+                              SUM_OF_BASE_QUALITIES. Possible values: {SUM_OF_BASE_QUALITIES,
+                              TOTAL_MAPPED_REFERENCE_LENGTH, RANDOM} 
+
+--FLOW_EFFECTIVE_QUALITY_THRESHOLD <Integer>
+                              Threshold for considering a quality value high enough to be included when calculating
+                              FLOW_QUALITY_SUM_STRATEGY calculation.  Default value: 15. 
+
+--FLOW_MODE <Boolean>         enable parameters and behavior specific to flow based reads.  Default value: false.
+                              Possible values: {true, false} 
+
+--FLOW_Q_IS_KNOWN_END <Boolean>
+                              Treat position of read trimming based on quality as the known end (relevant for flow based
+                              reads). Default false - if the read is trimmed on quality its end is not defined and the
+                              read is duplicate of any read starting at the same place.  Default value: false. Possible
+                              values: {true, false} 
+
+--FLOW_QUALITY_SUM_STRATEGY <Boolean>
+                              Use specific quality summing strategy for flow based reads. The strategy ensures that the
+                              same (and correct) quality value is used for all bases of the same homopolymer.  Default
+                              value: false. Possible values: {true, false} 
+
+--FLOW_SKIP_FIRST_N_FLOWS <Integer>
+                              Skip first N flows, starting from the read's start, when considering duplicates. Useful
+                              for flow based reads where sometimes there is noise in the first flows (for this argument,
+                              "read start" means 5' end).  Default value: 0. 
+
+--GA4GH_CLIENT_SECRETS <String>
+                              Google Genomics API client_secrets.json file path.  Default value: client_secrets.json. 
+
+--help,-h <Boolean>           display the help message  Default value: false. Possible values: {true, false} 
+
+--MAX_FILE_HANDLES_FOR_READ_ENDS_MAP,-MAX_FILE_HANDLES <Integer>
+                              Maximum number of file handles to keep open when spilling read ends to disk. Set this
+                              number a little lower than the per-process maximum number of file that may be open. This
+                              number can be found by executing the 'ulimit -n' command on a Unix system.  Default value:
+                              8000. 
+
+--MAX_OPTICAL_DUPLICATE_SET_SIZE <Long>
+                              This number is the maximum size of a set of duplicate reads for which we will attempt to
+                              determine which are optical duplicates.  Please be aware that if you raise this value too
+                              high and do encounter a very large set of duplicate reads, it will severely affect the
+                              runtime of this tool.  To completely disable this check, set the value to -1.  Default
+                              value: 300000. 
+
+--MAX_RECORDS_IN_RAM <Integer>When writing files that need to be sorted, this will specify the number of records stored
+                              in RAM before spilling to disk. Increasing this number reduces the number of file handles
+                              needed to sort the file, and increases the amount of RAM needed.  Default value: 500000. 
+
+--MAX_SEQUENCES_FOR_DISK_READ_ENDS_MAP,-MAX_SEQS <Integer>
+                              This option is obsolete. ReadEnds will always be spilled to disk.  Default value: 50000. 
+
+--MOLECULAR_IDENTIFIER_TAG <String>
+                              SAM tag to uniquely identify the molecule from which a read was derived.  Use of this
+                              option requires that the BARCODE_TAG option be set to a non null value.  Default null. 
+                              Default value: null. 
+
+--OPTICAL_DUPLICATE_PIXEL_DISTANCE <Integer>
+                              The maximum offset between two duplicate clusters in order to consider them optical
+                              duplicates. The default is appropriate for unpatterned versions of the Illumina platform.
+                              For the patterned flowcell models, 2500 is moreappropriate. For other platforms and
+                              models, users should experiment to find what works best.  Default value: 100. 
+
+--PROGRAM_GROUP_COMMAND_LINE,-PG_COMMAND <String>
+                              Value of CL tag of PG record to be created. If not supplied the command line will be
+                              detected automatically.  Default value: null. 
+
+--PROGRAM_GROUP_NAME,-PG_NAME <String>
+                              Value of PN tag of PG record to be created.  Default value: MarkDuplicates. 
+
+--PROGRAM_GROUP_VERSION,-PG_VERSION <String>
+                              Value of VN tag of PG record to be created. If not specified, the version will be detected
+                              automatically.  Default value: null. 
+
+--PROGRAM_RECORD_ID,-PG <String>
+                              The program record ID for the @PG record(s) created by this program. Set to null to
+                              disable PG record creation.  This string may have a suffix appended to avoid collision
+                              with other program record IDs.  Default value: MarkDuplicates. 
+
+--QUIET <Boolean>             Whether to suppress job-summary info on System.err.  Default value: false. Possible
+                              values: {true, false} 
+
+--READ_NAME_REGEX <String>    MarkDuplicates can use the tile and cluster positions to estimate the rate of optical
+                              duplication in addition to the dominant source of duplication, PCR, to provide a more
+                              accurate estimation of library size. By default (with no READ_NAME_REGEX specified),
+                              MarkDuplicates will attempt to extract coordinates using a split on ':' (see Note below). 
+                              Set READ_NAME_REGEX to 'null' to disable optical duplicate detection. Note that without
+                              optical duplicate counts, library size estimation will be less accurate. If the read name
+                              does not follow a standard Illumina colon-separation convention, but does contain tile and
+                              x,y coordinates, a regular expression can be specified to extract three variables:
+                              tile/region, x coordinate and y coordinate from a read name. The regular expression must
+                              contain three capture groups for the three variables, in order. It must match the entire
+                              read name.   e.g. if field names were separated by semi-colon (';') this example regex
+                              could be specified      (?:.*;)?([0-9]+)[^;]*;([0-9]+)[^;]*;([0-9]+)[^;]*$ Note that if no
+                              READ_NAME_REGEX is specified, the read name is split on ':'.   For 5 element names, the
+                              3rd, 4th and 5th elements are assumed to be tile, x and y values.   For 7 element names
+                              (CASAVA 1.8), the 5th, 6th, and 7th elements are assumed to be tile, x and y values. 
+                              Default value: <optimized capture of last three ':' separated fields as numeric values>. 
+
+--READ_ONE_BARCODE_TAG <String>
+                              Read one barcode SAM tag (ex. BX for 10X Genomics)  Default value: null. 
+
+--READ_TWO_BARCODE_TAG <String>
+                              Read two barcode SAM tag (ex. BX for 10X Genomics)  Default value: null. 
+
+--REFERENCE_SEQUENCE,-R <File>Reference sequence file.  Default value: null. 
+
+--REMOVE_DUPLICATES <Boolean> If true do not write duplicates to the output file instead of writing them with
+                              appropriate flags set.  Default value: false. Possible values: {true, false} 
+
+--REMOVE_SEQUENCING_DUPLICATES <Boolean>
+                              If true remove 'optical' duplicates and other duplicates that appear to have arisen from
+                              the sequencing process instead of the library preparation process, even if
+                              REMOVE_DUPLICATES is false. If REMOVE_DUPLICATES is true, all duplicates are removed and
+                              this option is ignored.  Default value: false. Possible values: {true, false} 
+
+--SORTING_COLLECTION_SIZE_RATIO <Double>
+                              This number, plus the maximum RAM available to the JVM, determine the memory footprint
+                              used by some of the sorting collections.  If you are running out of memory, try reducing
+                              this number.  Default value: 0.25. 
+
+--TAG_DUPLICATE_SET_MEMBERS <Boolean>
+                              If a read appears in a duplicate set, add two tags. The first tag, DUPLICATE_SET_SIZE_TAG
+                              (DS), indicates the size of the duplicate set. The smallest possible DS value is 2 which
+                              occurs when two reads map to the same portion of the reference only one of which is marked
+                              as duplicate. The second tag, DUPLICATE_SET_INDEX_TAG (DI), represents a unique identifier
+                              for the duplicate set to which the record belongs. This identifier is the index-in-file of
+                              the representative read that was selected out of the duplicate set.  Default value: false.
+                              Possible values: {true, false} 
+
+--TAGGING_POLICY <DuplicateTaggingPolicy>
+                              Determines how duplicate types are recorded in the DT optional attribute.  Default value:
+                              DontTag. Possible values: {DontTag, OpticalOnly, All} 
+
+--TMP_DIR <File>              One or more directories with space available to be used by this program for temporary
+                              storage of working files  This argument may be specified 0 or more times. Default value:
+                              null. 
+
+--UNPAIRED_END_UNCERTAINTY <Integer>
+                              Maximal difference of the read end position that counted as equal. Useful for flow based
+                              reads where the end position might vary due to sequencing errors. (for this argument,
+                              "read end" means 3' end)  Default value: 0. 
+
+--USE_END_IN_UNPAIRED_READS <Boolean>
+                              Make the end location of single end read be significant when considering duplicates, in
+                              addition to the start location, which is always significant (i.e. require single-ended
+                              reads to start andend on the same position to be considered duplicate) (for this argument,
+                              "read end" means 3' end).  Default value: false. Possible values: {true, false} 
+
+--USE_JDK_DEFLATER,-use_jdk_deflater <Boolean>
+                              Use the JDK Deflater instead of the Intel Deflater for writing compressed output  Default
+                              value: false. Possible values: {true, false} 
+
+--USE_JDK_INFLATER,-use_jdk_inflater <Boolean>
+                              Use the JDK Inflater instead of the Intel Inflater for reading compressed input  Default
+                              value: false. Possible values: {true, false} 
+
+--USE_UNPAIRED_CLIPPED_END <Boolean>
+                              Use position of the clipping as the end position, when considering duplicates (or use the
+                              unclipped end position) (for this argument, "read end" means 3' end).  Default value:
+                              false. Possible values: {true, false} 
+
+--VALIDATION_STRINGENCY <ValidationStringency>
+                              Validation stringency for all SAM files read by this program.  Setting stringency to
+                              SILENT can improve performance when processing a BAM file in which variable-length data
+                              (read, qualities, tags) do not otherwise need to be decoded.  Default value: STRICT.
+                              Possible values: {STRICT, LENIENT, SILENT} 
+
+--VERBOSITY <LogLevel>        Control verbosity of logging.  Default value: INFO. Possible values: {ERROR, WARNING,
+                              INFO, DEBUG} 
+
+--version <Boolean>           display the version number for this tool  Default value: false. Possible values: {true,
+                              false} 
+
+
+Advanced Arguments:
+
+--showHidden <Boolean>        display hidden arguments  Default value: false. Possible values: {true, false} 
+
diff --git a/tests/tool_audit/help/piranha_help.txt b/tests/tool_audit/help/piranha_help.txt
new file mode 100644
index 00000000..78852302
--- /dev/null
+++ b/tests/tool_audit/help/piranha_help.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+ERROR:	cannot open input file --help
diff --git a/tests/tool_audit/help/piscem_build.txt b/tests/tool_audit/help/piscem_build.txt
new file mode 100644
index 00000000..4656fb38
--- /dev/null
+++ b/tests/tool_audit/help/piscem_build.txt
@@ -0,0 +1,52 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Index a reference sequence
+
+Usage: piscem build [OPTIONS] --threads <THREADS> --output <OUTPUT> <--ref-seqs <REF_SEQS>|--ref-lists <REF_LISTS>|--ref-dirs <REF_DIRS>>
+
+Options:
+  -o, --output <OUTPUT>            output file stem
+      --decoy-paths <DECOY_PATHS>  path to (optional) ',' sparated list of decoy sequences used to
+                                   insert poison k-mer information into the index
+  -h, --help                       Print help
+  -V, --version                    Print version
+
+Input:
+  -s, --ref-seqs <REF_SEQS>    ',' separated list of reference FASTA files
+  -l, --ref-lists <REF_LISTS>  ',' separated list of files (each listing input FASTA files)
+  -d, --ref-dirs <REF_DIRS>    ',' separated list of directories (all FASTA files in each directory
+                               will be indexed, but not recursively)
+
+Index Construction Parameters:
+  -k, --klen <KLEN>
+          length of k-mer to use, must be <= 31 and odd [default: 31]
+  -m, --mlen <MLEN>
+          length of minimizer to use; must be < `klen` [default: 19]
+  -t, --threads <THREADS>
+          number of threads to use
+      --no-ec-table
+          skip the construction of the equivalence class lookup table when building the index (not
+          recommended)
+      --polya-clip-length <POLYA_CLIP_LENGTH>
+          If provided (default is not to clip polyA), then reference sequences ending with polyA
+          tails of length greater than or equal to this value will be clipped
+      --seed <SEED>
+          index construction seed (seed value passed to SSHash index construction; useful if empty
+          buckets occur) [default: 1]
+      --dict <DICT>
+          dictionary artifacts to emit: `auto` (default), `sshash`, or `tiny` [default: auto]
+          [possible values: auto, sshash, tiny]
+
+Indexing Details:
+      --keep-intermediate-dbg          retain the reduced format GFA files produced by cuttlefish
+                                       that describe the reference cDBG (the default is to remove
+                                       these)
+  -w, --work-dir <WORK_DIR>            working directory where temporary files should be placed
+                                       [default: ./workdir.noindex]
+      --overwrite                      overwite an existing index if the output path is the same
+      --tmp-dir <TMP_DIR>              directory for SSHash's external minimizer-sort scratch files.
+                                       This is a distinct, later phase from the cDBG construction
+                                       that `--work-dir` covers. Unset keeps SSHash's default
+                                       (`sshash_tmp` in the current directory)
+      --ram-limit-gib <RAM_LIMIT_GIB>  RAM ceiling, in GiB, for SSHash's external minimizer sort.
+                                       Unset keeps SSHash's default (8 GiB); a smaller value spills
+                                       to disk sooner
diff --git a/tests/tool_audit/help/piscem_mapsc.txt b/tests/tool_audit/help/piscem_mapsc.txt
new file mode 100644
index 00000000..36fae796
--- /dev/null
+++ b/tests/tool_audit/help/piscem_mapsc.txt
@@ -0,0 +1,104 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+map reads for single-cell processing
+
+Usage: piscem map-sc [OPTIONS] --index <INDEX> --geometry <GEOMETRY> --read1 <READ1> --read2 <READ2> --output <OUTPUT>
+
+Options:
+  -g, --geometry <GEOMETRY>
+          geometry of barcode, umi and read
+
+  -t, --threads <THREADS>
+          total execution-slot budget shared by mapping and gzip decoding
+          
+          [default: 16]
+
+      --decoder <MODE>
+          Gzip decoder selection: `auto`, `serial`, `parallel`, or `parallel=N`.
+          
+          `auto` adapts the aggregate mapping/decode split during the real run. `serial` gives
+          mapping the full budget. `parallel` forces the parallel path but still adapts its split;
+          `parallel=N` fixes N slots per decoder-capable input and disables adaptation. Non-regular
+          inputs remain serial because the parallel decoder requires positional reads.
+          
+          [default: auto]
+
+      --thread-policy <FILE>
+          Path to a JSON file overriding thread and decoder policy.
+          
+          Every field is optional and defaults to a measured value, so a file need only name what it
+          changes; an unknown field is an error rather than a silent no-op. Currently:
+          
+          `{"parallel_decode": {"min_threads_per_stream": 8}}`
+          
+          That value is how many threads must be available per gzip input before the parallel
+          decoder is used at all. Below it the serial decoder already supplies one inflate stream
+          per input for free, on threads that also map.
+
+  -o, --output <OUTPUT>
+          path to output directory
+
+      --no-poison
+          do not consider poison k-mers, even if the underlying index contains them. In this case,
+          the mapping results will be identical to those obtained as if no poison table was added to
+          the index
+
+  -c, --struct-constraints
+          apply structural constraints when performing mapping
+
+      --skipping-strategy <SKIPPING_STRATEGY>
+          the skipping strategy to use for k-mer collection
+          
+          [default: permissive]
+          [possible values: permissive, strict]
+
+      --ignore-ambig-hits
+          skip checking of the equivalence classes of k-mers that were too ambiguous to be otherwise
+          considered (passing this flag can speed up mapping slightly, but may reduce specificity)
+
+      --with-position
+          includes the positions of each mapped read in the resulting RAD file
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
+
+Input:
+  -i, --index <INDEX>
+          input index prefix
+
+  -1, --read1 <READ1>
+          path to a ',' separated list of read 1 files
+
+  -2, --read2 <READ2>
+          path to a ',' separated list of read 2 files
+
+Advanced options:
+  -m, --max-ec-card <MAX_EC_CARD>
+          determines the maximum cardinality equivalence class (number of (txp, orientation status)
+          pairs) to examine (cannot be used with --ignore-ambig-hits)
+          
+          [default: 4096]
+
+      --max-hit-occ <MAX_HIT_OCC>
+          in the first pass, consider only k-mers having <= --max-hit-occ hits
+          
+          [default: 256]
+
+      --max-hit-occ-recover <MAX_HIT_OCC_RECOVER>
+          if all k-mers have > --max-hit-occ hits, then make a second pass and consider k-mers
+          having <= --max-hit-occ-recover hits
+          
+          [default: 1024]
+
+      --max-read-occ <MAX_READ_OCC>
+          reads with more than this number of mappings will not have their mappings reported
+          
+          [default: 2500]
+
+      --dict <DICT>
+          dictionary backend: `auto` (default), `sshash`, or `tiny`
+          
+          [default: auto]
+          [possible values: auto, sshash, tiny]
diff --git a/tests/tool_audit/help/rustqc.txt b/tests/tool_audit/help/rustqc.txt
new file mode 100644
index 00000000..0b211c0b
--- /dev/null
+++ b/tests/tool_audit/help/rustqc.txt
@@ -0,0 +1,12 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Fast RNA-seq QC in a single pass: dupRadar, featureCounts, 8 RSeQC tools, preseq, samtools stats, and Qualimap — reimplemented in Rust
+
+Usage: rustqc-avx512 <COMMAND>
+
+Commands:
+  rna   RNA-Seq QC — single-pass analysis of BAM/SAM/CRAM files
+  help  Print this message or the help of the given subcommand(s)
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
diff --git a/tests/tool_audit/help/rustqc_rna.txt b/tests/tool_audit/help/rustqc_rna.txt
new file mode 100644
index 00000000..fb972ce7
--- /dev/null
+++ b/tests/tool_audit/help/rustqc_rna.txt
@@ -0,0 +1,195 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+RNA-Seq QC — single-pass analysis of BAM/SAM/CRAM files.
+
+Runs featureCounts, dupRadar, Qualimap, samtools stats, and RSeQC analyses in one pass. Requires a GTF annotation and duplicate-marked (not removed) alignments.
+
+Usage: rustqc-avx512 rna [OPTIONS] --gtf <GTF> <INPUT>...
+
+Options:
+  -h, --help
+          Print help (see a summary with '-h')
+
+Input / Output:
+  -g, --gtf <GTF>
+          GTF gene annotation (plain or .gz)
+          
+          [env: RUSTQC_GTF=]
+
+  -r, --reference <FASTA>
+          Reference FASTA (required for CRAM)
+          
+          [env: RUSTQC_REFERENCE=]
+
+  -o, --outdir <OUTDIR>
+          Output directory [default: .]
+          
+          [env: RUSTQC_OUTDIR=]
+
+      --sample-name <NAME>
+          Override sample name for output filenames (default: derived from BAM filename)
+          
+          [env: RUSTQC_SAMPLE_NAME=]
+
+      --flat-output
+          Write outputs to a flat directory (no subdirs)
+          
+          [env: RUSTQC_FLAT_OUTPUT=]
+
+  -c, --config <CONFIG>
+          YAML configuration file (see also: RUSTQC_CONFIG env var)
+
+  -j, --json-summary [<PATH>]
+          JSON summary path (use "-" for stdout)
+          
+          [env: RUSTQC_JSON_SUMMARY=]
+
+  <INPUT>...
+          Duplicate-marked alignment file(s)
+
+Library:
+  -s, --stranded <STRANDED>
+          Strandedness: unstranded, forward, reverse
+
+          Possible values:
+          - unstranded: Count reads on either strand (library is not strand-specific)
+          - forward:    Forward stranded: read 1 maps to the transcript strand
+          - reverse:    Reverse stranded: read 2 maps to the transcript strand (e.g. dUTP)
+          
+          [env: RUSTQC_STRANDED=]
+
+  -p, --paired
+          Paired-end reads
+          
+          [env: RUSTQC_PAIRED=]
+
+General:
+  -t, --threads <THREADS>
+          Number of threads [default: 1]
+          
+          [env: RUSTQC_THREADS=]
+
+  -Q, --mapq <MAPQ_CUT>
+          MAPQ cutoff for quality filtering [default: 30]
+          
+          [env: RUSTQC_MAPQ=]
+
+      --biotype-attribute <ATTR>
+          GTF attribute for biotype grouping
+          
+          [env: RUSTQC_BIOTYPE_ATTRIBUTE=]
+
+      --skip-dup-check
+          Skip duplicate-marking check
+          
+          [env: RUSTQC_SKIP_DUP_CHECK=]
+
+  -q, --quiet
+          Suppress output except warnings/errors
+          
+          [env: RUSTQC_QUIET=]
+
+  -v, --verbose
+          Show additional detail
+          
+          [env: RUSTQC_VERBOSE=]
+
+Tool parameters:
+      --infer-experiment-sample-size <N>
+          infer_experiment: sample size [default: 200000]
+          
+          [env: RUSTQC_INFER_EXPERIMENT_SAMPLE_SIZE=]
+
+      --min-intron <N>
+          junction_annotation: min intron size [default: 50]
+          
+          [env: RUSTQC_MIN_INTRON=]
+
+      --junction-saturation-seed <N>
+          junction_saturation: random seed for reproducible results
+          
+          [env: RUSTQC_JUNCTION_SATURATION_SEED=]
+
+      --junction-saturation-min-coverage <N>
+          junction_saturation: min coverage [default: 1]
+          
+          [env: RUSTQC_JUNCTION_SATURATION_MIN_COVERAGE=]
+
+      --junction-saturation-percentile-floor <N>
+          junction_saturation: start % [default: 5]
+          
+          [env: RUSTQC_JUNCTION_SATURATION_PERCENTILE_FLOOR=]
+
+      --junction-saturation-percentile-ceiling <N>
+          junction_saturation: end % [default: 100]
+          
+          [env: RUSTQC_JUNCTION_SATURATION_PERCENTILE_CEILING=]
+
+      --junction-saturation-percentile-step <N>
+          junction_saturation: step % [default: 5]
+          
+          [env: RUSTQC_JUNCTION_SATURATION_PERCENTILE_STEP=]
+
+      --inner-distance-sample-size <N>
+          inner_distance: sample size [default: 1000000]
+          
+          [env: RUSTQC_INNER_DISTANCE_SAMPLE_SIZE=]
+
+      --inner-distance-lower-bound <N>
+          inner_distance: lower bound [default: -250]
+          
+          [env: RUSTQC_INNER_DISTANCE_LOWER_BOUND=]
+
+      --inner-distance-upper-bound <N>
+          inner_distance: upper bound [default: 250]
+          
+          [env: RUSTQC_INNER_DISTANCE_UPPER_BOUND=]
+
+      --inner-distance-step <N>
+          inner_distance: bin width [default: 5]
+          
+          [env: RUSTQC_INNER_DISTANCE_STEP=]
+
+      --tin-seed <N>
+          TIN: random seed for reproducible results
+          
+          [env: RUSTQC_TIN_SEED=]
+
+      --skip-tin
+          Skip TIN analysis
+          
+          [env: RUSTQC_SKIP_TIN=]
+
+      --skip-read-duplication
+          Skip read duplication analysis
+          
+          [env: RUSTQC_SKIP_READ_DUPLICATION=]
+
+      --skip-preseq
+          Skip preseq library complexity analysis
+          
+          [env: RUSTQC_SKIP_PRESEQ=]
+
+      --preseq-seed <N>
+          preseq: random seed for bootstrap CIs
+          
+          [env: RUSTQC_PRESEQ_SEED=]
+
+      --preseq-max-extrap <N>
+          preseq: max extrapolation depth
+          
+          [env: RUSTQC_PRESEQ_MAX_EXTRAP=]
+
+      --preseq-step-size <N>
+          preseq: step size between points
+          
+          [env: RUSTQC_PRESEQ_STEP_SIZE=]
+
+      --preseq-n-bootstraps <N>
+          preseq: bootstrap replicates for CIs
+          
+          [env: RUSTQC_PRESEQ_N_BOOTSTRAPS=]
+
+      --preseq-seg-len <N>
+          preseq: max segment length for PE merging
+          
+          [env: RUSTQC_PRESEQ_SEG_LEN=]
diff --git a/tests/tool_audit/help/salmon.txt b/tests/tool_audit/help/salmon.txt
new file mode 100644
index 00000000..3cbad9b8
--- /dev/null
+++ b/tests/tool_audit/help/salmon.txt
@@ -0,0 +1,17 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+RNA-seq transcript quantification
+
+Usage: salmon [OPTIONS] <COMMAND>
+
+Commands:
+  index       Build a salmon index from a transcriptome FASTA
+  quant       Quantify transcript abundances from FASTQ reads
+  quantmerge  Merge a column across multiple samples' quant files into a matrix
+  debug-map   Diagnostic: per-read best-mapping detail (placement, seed coverage, score)
+  help        Print this message or the help of the given subcommand(s)
+
+Options:
+  -q, --quiet             Reduce logging to warnings and errors only
+      --no-version-check  Accepted for compatibility with C++ salmon. salmon 2.0 never contacts the network to check for a newer release, so this flag (and the `SALMON_NO_VERSION_CHECK` environment variable) is a no-op
+  -h, --help              Print help
+  -V, --version           Print version
diff --git a/tests/tool_audit/help/salmon_alevin.txt b/tests/tool_audit/help/salmon_alevin.txt
new file mode 100644
index 00000000..e8ca97d3
--- /dev/null
+++ b/tests/tool_audit/help/salmon_alevin.txt
@@ -0,0 +1,8 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+salmon alevin is not available in salmon 2.0.
+
+Single-cell quantification has moved to the alevin-fry ecosystem:
+  - piscem / salmon (this tool) for mapping → RAD
+  - alevin-fry for cell-barcode/UMI resolution and counting
+
+See https://github.com/COMBINE-lab/alevin-fry and https://alevin-fry.readthedocs.io
diff --git a/tests/tool_audit/help/salmon_index.txt b/tests/tool_audit/help/salmon_index.txt
new file mode 100644
index 00000000..8c5820ce
--- /dev/null
+++ b/tests/tool_audit/help/salmon_index.txt
@@ -0,0 +1,24 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Build a salmon index from a transcriptome FASTA
+
+Usage: salmon index [OPTIONS] --transcripts <TRANSCRIPTS>... --index <INDEX>
+
+Options:
+  -t, --transcripts <TRANSCRIPTS>...   Transcript FASTA file(s)
+  -i, --index <INDEX>                  Output index directory
+  -k, --kmerLen <KMER_LEN>             K-mer length (odd, ≤ 31 recommended) [default: 31]
+  -m, --minimizerLen <MINIMIZER_LEN>   Minimizer length (0 = auto; 19 for the default k=31) [default: 0]
+  -p, --threads <THREADS>              Worker threads (0 = all cores) [default: 0]
+      --keepIntermediate               Keep the intermediate compacted-dBG files
+      --keepFixedFasta                 Keep the post-cleaning ("fixed") reference FASTA (non-ACGT bases replaced) instead of deleting it after the index is built
+  -q, --quiet                          Reduce logging to warnings and errors only
+      --filterSize <FILTER_SIZE>       [accepted for salmon compatibility; no effect] TwoPaCo bloom-filter size — the Rust index builder (cf1-rs) does not expose this knob
+      --no-version-check               Accepted for compatibility with C++ salmon. salmon 2.0 never contacts the network to check for a newer release, so this flag (and the `SALMON_NO_VERSION_CHECK` environment variable) is a no-op
+      --tmpdir <TMPDIR>                Directory for build intermediates (cleaned FASTA + cDBG files); the final index still lands in --index. Defaults to the index dir. (salmon's --tmpdir)
+      --sshashTmpDir <SSHASH_TMP_DIR>  Directory for sshash's external minimizer-sort scratch. Defaults to a `sshash_tmp` subdirectory of --tmpdir (or the index dir when --tmpdir is unset). Override to place the sort scratch on a separate/fast disk; the directory is created before the build and removed afterwards
+      --ramLimit <RAM_LIMIT_GIB>       RAM ceiling, in GiB, for sshash's external minimizer sort (the main build-time memory/disk trade-off). Default is 8; a smaller value uses less RAM but spills to disk sooner
+      --keepDuplicates                 Retain exact-duplicate transcript sequences instead of collapsing them (salmon collapses duplicates by default)
+      --gencode                        GENCODE-format references: truncate each transcript name at the first `|` (e.g. `ENST...|ENSG...|...` -> `ENST...`)
+  -d, --decoys <DECOYS>                File of decoy sequence names (one per line). The named records (which must appear last in the FASTA) are indexed but flagged as decoys
+  -n, --no-clip                        Don't clip poly-A tails from the ends of target sequences. By default (matching salmon/pufferfish `FixFasta`), a reference ending in a run of at least 10 `A`s has its trailing `A`s trimmed before indexing (an all-`A` reference is dropped)
+  -h, --help                           Print help
diff --git a/tests/tool_audit/help/salmon_quant.txt b/tests/tool_audit/help/salmon_quant.txt
new file mode 100644
index 00000000..c586a65f
--- /dev/null
+++ b/tests/tool_audit/help/salmon_quant.txt
@@ -0,0 +1,428 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Quantify transcript abundances from FASTQ reads
+
+Usage: salmon quant [OPTIONS] --output <OUTPUT>
+
+Options:
+  -i, --index <INDEX>
+          Salmon index directory (reads mode)
+
+  -a, --alignments <ALIGNMENTS>
+          Alignment-based mode: a BAM of reads aligned to the transcriptome
+
+      --rad <RAD>
+          RAD-input mode: a RAD file of mappings (from `salmon quant --writeRad` or `piscem map-bulk`) to quantify directly, in parallel
+
+  -t, --targets <TARGETS>
+          Transcriptome FASTA (alignment mode `-a`): enables the alignment error model
+
+      --noErrorModel
+          Disable the alignment error model (alignment mode)
+
+      --errorModel
+          Opt in to the order-independent alignment error model in deterministic mode (`-a --deterministic`, requires `-t`). Off by default: deterministic mode scores by the BAM `AS` tag, which benchmarks at least as accurately against ground truth and needs only a single BAM pass; `--errorModel` adds a second pass to train the model. Use it for parity with salmon's classic error-modeled quant, or when the aligner's `AS` is absent/unreliable
+
+      --annotation <GTF|GFF>
+          Genome-alignment mode: a GTF/GFF annotation. Given with `-a <genome.bam>`, salmon projects the spliced genome alignments into transcriptome coordinates (via bramble) and quantifies the projected placements. The transcript set is taken from the annotation
+
+  -q, --quiet
+          Reduce logging to warnings and errors only
+
+      --genome <FASTA>
+          Genome FASTA (genome-alignment mode) — needed only for bias correction, to reconstruct transcript sequences from the annotation's exons
+
+      --no-version-check
+          Accepted for compatibility with C++ salmon. salmon 2.0 never contacts the network to check for a newer release, so this flag (and the `SALMON_NO_VERSION_CHECK` environment variable) is a no-op
+
+      --juncMissDiscount <F>
+          Genome-alignment projection: penalty multiplier per junction mismatch (bramble `junc_miss_discount`; default 1.0 = no penalty)
+
+  -l, --libType <LIB_TYPE>
+          Library type (e.g. IU, ISR, A for auto)
+          
+          [default: A]
+
+  -1, --mates1 <MATES1>...
+          Mate-1 FASTQ file(s) for paired-end reads
+
+  -2, --mates2 <MATES2>...
+          Mate-2 FASTQ file(s) for paired-end reads
+
+  -r, --unmatedReads <UNMATED>...
+          Single-end FASTQ file(s)
+
+  -o, --output <OUTPUT>
+          Output directory
+
+  -g, --geneMap <FILE>
+          Transcript-to-gene map (GTF/GFF, or a 2-column TSV), optionally compressed (gzip, BGZF, bzip2, xz, zstd); also writes gene-level estimates to `quant.genes.sf`
+
+      --ignoreTxVersion
+          Ignore trailing transcript-version suffixes when joining `--geneMap` entries to quantified transcripts, so `ENST00000456328.2` matches `ENST00000456328`. Matches tximport's option of the same name. Needed when the index was built from an Ensembl cDNA FASTA, which carries the version in the identifier, and the annotation is an Ensembl GTF, which puts it in a separate `transcript_version` attribute
+
+  -p, --threads <THREADS>
+          Worker threads (0 = all cores). salmon also runs one auxiliary thread for FASTQ parsing/decompression, so total CPU use can slightly exceed this value; on schedulers that enforce the limit, request one extra core
+          
+          [default: 0]
+
+      --decoder <DECODER>
+          Which gzip decoder to use: `auto` (default), `serial`, `parallel`, or `parallel=N` to pin N slots per decodable input.
+          
+          `-p` is one budget shared between inflating the input and mapping it, so engaging the parallel decoder costs mapping threads. `auto` engages it only when the budget is large enough for it to add decode concurrency rather than merely move threads around -- a threshold that is higher in selective-alignment mode than in sketch, because more work per fragment means a smaller share of the budget should be decoding.
+          
+          [default: auto]
+
+      --threadPolicy <FILE>
+          JSON file overriding thread and decoder policy.
+          
+          Every field is optional and an unknown field is an error rather than a silent no-op, so a typo refuses to load instead of leaving the run looking configured while behaving as if it were not. Example: `{"parallel_decode": {"min_threads_per_stream": 16}}`.
+
+      --sketch
+          Use the alignment-free pseudoalignment path
+
+      --sketchStrictOrphans
+          Sketch mode: only emit an orphan when the mate had no matching k-mers at all (strict). Default orphans whenever the mate has no consistent target, which tracks selective alignment more closely
+
+      --useEM
+          Use the standard EM optimizer instead of VBEM
+
+      --no-progress
+          Disable the live mapping progress spinner (it is shown only on an interactive terminal and never when `--quiet`)
+
+      --meta
+          Metagenomic preset (salmon's `--meta`): use plain EM (not VBEM), disable range-factorized/rich equivalence classes, and initialize abundances uniformly — settings better suited to metagenomic references. Overrides `--useEM`/`--rangeFactorizationBins`
+
+      --rangeFactorizationBins <RANGE_FACTORIZATION_BINS>
+          Range-factorization bins for equivalence classes (0 disables)
+          
+          [default: 4]
+
+      --incompatPrior <INCOMPAT_PRIOR>
+          Prior weight for strand-incompatible mappings (0 drops them)
+          
+          [default: 0]
+
+      --dumpEq
+          Dump equivalence classes to aux_info/eq_classes.txt.gz (salmon format)
+
+      --dumpEqWeights
+          Like --dumpEq, but also write per-transcript weights in each class
+
+      --writeUnmappedNames
+          Write the names of unmapped fragments to aux_info/unmapped_names.txt
+
+  -z, --writeMappings <WRITE_MAPPINGS>
+          Write per-mapping SAM records to this file (spoofed CIGAR, like salmon's standard `--writeMappings`). `--writeSam` is an accepted alias, naming the format explicitly to pair with `--writeBam`
+          
+          [alias: --writeSam]
+
+      --writeBam <WRITE_BAM>
+          Write per-mapping BAM records to this file. Mutually exclusive with --writeMappings/--writeSam
+
+      --bamCompressThreads <BAM_COMPRESS_THREADS>
+          BGZF compression workers for --writeBam [default: about one per 3 mapping threads, at most 8].
+          
+          These threads run alongside the -p mapping threads and do nothing but compress BGZF blocks. The default balances the two stages from measured throughput: one worker compresses ~165 MiB/s of BAM records, while one mapping thread produces at most ~52 MiB/s of them, so roughly one worker per 3 mapping threads keeps compression from becoming the bottleneck. The result is capped at 8, which is already about 3x the fastest record production measured at any thread count.
+          
+          The cost is very lopsided, so the default errs upward: one worker too few can halve throughput, whereas surplus workers just block on an empty queue and cost nothing measurable. It stops at the balance point rather than going higher, because past that these cores do more good mapping reads. Raise it if you are writing BAM to unusually fast storage and can spare the cores; there is no reason to lower it.
+
+      --writeRad <WRITE_RAD>
+          Write per-fragment mappings to a RAD file at this path. Sketch or selective-alignment profile is chosen automatically from the mapping mode. Quantification still runs; add --skipQuant to map only. The file is piscem map-bulk compatible and can be re-quantified with `--rad`
+
+      --deterministic
+          Deterministic quantification (reads/FASTQ input): map once to an intermediate RAD, then quantify from it with a fixed fragment-length distribution, so the result is byte-identical across runs and thread counts. Avoids a second mapping pass. The intermediate RAD is written under the output directory and deleted on success unless --keepRad (or use --writeRad PATH to choose its location and keep it)
+
+      --keepRad
+          Keep the intermediate RAD produced by --deterministic (by default it is deleted once quantification finishes). Ignored without --deterministic
+
+      --seqBias
+          Enable sequence-specific bias correction
+
+      --gcBias
+          Enable fragment-GC bias correction
+
+      --posBias
+          Enable positional bias correction
+
+      --radCompress <RAD_COMPRESS>
+          Compression codec for RAD output (`--writeRad` and the `--deterministic` intermediate): `lz4` (default), `zstd` (better ratio), or `none`
+          
+          [default: lz4]
+          [possible values: lz4, zstd, none]
+
+      --noCompressRad
+          Write uncompressed RAD chunks (overrides --radCompress)
+
+      --numBootstraps <NUM_BOOTSTRAPS>
+          Number of bootstrap replicates for posterior uncertainty
+          
+          [default: 0]
+
+      --numGibbsSamples <NUM_GIBBS_SAMPLES>
+          Number of Gibbs posterior samples (mutually exclusive with bootstraps).
+          
+          `conflicts_with` makes that exclusivity real. It was previously only stated in this doc comment and resolved silently by dispatch order, so passing both ran the bootstrap and ignored the Gibbs request without saying so.
+          
+          [default: 0]
+
+      --thinningFactor <THINNING_FACTOR>
+          Gibbs thinning factor
+          
+          [default: 16]
+
+      --ont
+          (Long reads) Oxford Nanopore model — not supported; use oarfish instead
+
+      --noLengthCorrection
+          Disable effective-length correction (use raw reference length)
+
+      --minScoreFraction <MIN_SCORE_FRACTION>
+          Minimum alignment score as a fraction of the perfect score
+          
+          [default: 0.65]
+
+      --orphanChainSubThresh <ORPHAN_CHAIN_SUB_THRESH>
+          Orphan chain sub-optimality threshold (salmon's `orphanChainSubThresh`). `0.0` (default) aligns every orphan candidate (more sensitive than salmon's 0.95, which prunes low-chain-coverage orphans before alignment)
+          
+          [default: 0]
+
+      --fullLengthAlignment
+          Score the full read with one DP instead of PuffAligner-style inter-MEM-gap scoring
+
+      --sparseSeeds
+          Seed with sparse fixed-k k-mer anchors instead of the default unitig-constrained uni-MEMs
+
+      --refMEMs
+          Seed with reference-extended MEMs (cross unitig boundaries)
+
+      --uniMEMs
+          Seed with true unitig-constrained uni-MEMs (pufferfish-style). This is the default; the flag is accepted for explicitness/back-compat
+
+      --ma <MA>
+          Match score for selective alignment (reads mode)
+          
+          [default: 2]
+
+      --mp <MP>
+          Mismatch penalty for selective alignment (reads mode)
+          
+          [default: 4]
+
+      --go <GO>
+          Gap-open penalty for selective alignment (reads mode)
+          
+          [default: 6]
+
+      --ge <GE>
+          Gap-extend penalty for selective alignment (reads mode)
+          
+          [default: 2]
+
+      --consensusSlack <CONSENSUS_SLACK>
+          Consensus slack: a target is kept only if its best chain score is at least `(1 - slack)` of the max chain score for that mate (salmon default 0.35; `1.0` keeps every target)
+          
+          [default: 0.35]
+
+      --maxOccsPerHit <MAX_OCCS_PER_HIT>
+          Skip k-mers whose unitig occurs in more than this many references (repetitive-hit guard; salmon's `maxOccsPerHit`)
+          
+          [default: 1000]
+
+      --vbPrior <VB_PRIOR>
+          VBEM per-feature Dirichlet prior weight
+          
+          [default: 0.01]
+
+      --emAccel <EM_ACCEL>
+          EM/VBEM convergence acceleration. `squarem` reaches the same abundances in far fewer M-steps but is not byte-identical to the default `none`
+
+          Possible values:
+          - none:    Plain fixed-point iteration; output unchanged from historical salmon
+          - squarem: SQUAREM acceleration (same fixpoint, far fewer M-steps; not byte-identical)
+          - daarem:  DAAREM: damped Anderson acceleration over a window of past iterates; faster than SQUAREM on high-dimensional problems. Same fixpoint; not byte-identical
+          
+          [default: none]
+
+      --fldMean <FLD_MEAN>
+          Mean of the fragment-length distribution prior [default: 250].
+          
+          A prior, not an override: wherever fragment lengths are observed, this seeds the distribution with weight 1 and the observations dominate. With `--rad` it is ignored entirely unless `--fldPolicy` says otherwise, since a salmon RAD carries a baked distribution.
+
+      --fldSD <FLD_SD>
+          Standard deviation of the fragment-length distribution prior [default: 25].
+          
+          Same prior semantics as `--fldMean`.
+
+      --fldMax <FLD_MAX>
+          Maximum fragment length tracked by the fragment-length distribution [default: 1000]
+
+      --fldPolicy <FLD_POLICY>
+          Where the fragment-length distribution comes from when quantifying a RAD (`--rad` only) [default: baked].
+          
+          salmon's RAD writer always bakes its fragment-length distribution into the header, so by default a requant reproduces the writing run exactly and `--fldMean`/`--fldSD` have no effect. Use `derive` to re-derive the distribution from the RAD's own fragment lengths, or `prior` to use `--fldMean`/`--fldSD` alone — `prior` is the setting that makes a fragment-length sensitivity analysis actually vary anything.
+
+          Possible values:
+          - baked:  Prefer the distribution baked into the RAD header (exact parity with the run that wrote it); otherwise derive it, or fall back to the prior
+          - derive: Ignore any baked distribution; re-derive it from this RAD's own uniquely-mapped proper pairs
+          - prior:  Ignore both the baked distribution and the RAD's fragment lengths; use `--fldMean`/`--fldSD` alone
+          
+          [default: baked]
+
+  -f, --forgettingFactor <FORGETTING_FACTOR>
+          Online-phase forgetting factor in (0.5, 1.0]
+          
+          [default: 0.65]
+
+      --initUniform
+          Initialize the optimizer uniformly instead of from the online estimates
+
+      --perTranscriptPrior
+          Interpret --vbPrior as a per-transcript prior (salmon's default)
+
+      --perNucleotidePrior
+          Interpret --vbPrior as a per-nucleotide prior (scaled by effective length)
+
+      --sigDigits <SIG_DIGITS>
+          Significant digits for the EffectiveLength and NumReads columns of quant.sf
+          
+          [default: 3]
+
+  -w, --maxReadOcc <MAX_READ_OCC>
+          Discard a read/fragment that maps to more than this many places — counting the total set of distinct mappings (concordant + orphan union) (reads mode)
+          
+          [default: 250]
+
+      --orphansRequireUnmappedMate
+          Only emit a single-mate (orphan) mapping when the read's mate is entirely unmapped. By default, when a pair has no concordant mapping, orphans are reported for both mates (their union); with this flag a read that maps only because its mate also mapped (to a disjoint set) is not reported as an orphan
+
+      --allowDovetail
+          Allow dovetailed mappings (mates extending past each other) as concordant
+
+      --bandwidth <BANDWIDTH>
+          ksw2 DP bandwidth for selective alignment (reads mode)
+          
+          [default: 15]
+
+      --recoverOrphans
+          Attempt to recover the mate of an orphaned read near its mapped partner (selective-alignment mode). Off by default
+
+      --discardOrphansQuasi
+          Discard orphan mappings in selective-alignment (reads) mode: only concordantly-paired fragments are kept
+
+      --decoyThreshold <DECOY_THRESHOLD>
+          An alignment to an annotated transcript is invalid if its score is `< decoyThreshold * bestDecoyScore` (selective-alignment mode)
+          
+          [default: 1]
+
+      --minAlnProb <MIN_ALN_PROB>
+          Drop any mapping whose alignment probability `exp(-scoreExp * (best - score))` is below this (selective-alignment mode)
+          
+          [default: 0.00001]
+
+      --scoreExp <SCORE_EXP>
+          Soft-weight decay: a mapping's probability is proportional to `exp(-scoreExp * (bestScore - score))`. Larger downweights sub-optimal mappings more steeply. (salmon's --scoreExp; default 1.0)
+          
+          [default: 1]
+
+      --hardFilter
+          Instead of soft-weighting multimapping locations by alignment score, keep only the best-scoring mapping(s), each with equal weight
+
+      --allowDecoyOrphans
+          When a fragment's best transcript alignment is outscored by a decoy (genome) alignment, keep the transcript placement instead of discarding the fragment. Off by default (decoy-dominated fragments are dropped, matching salmon). Increases the reported mapping rate on decoy-aware indices at the cost of retaining transcript mappings for fragments better explained by the genome; only affects fragments that retain a transcript candidate
+
+      --softclip
+          Allow soft-clipping of read ends during selective alignment: unaligned read-end bases are clipped rather than penalized. (salmon's --softclip)
+
+      --softclipOverhangs
+          Allow soft-clipping only of read bases that overhang a transcript end (a restricted form of --softclip). (salmon's --softclipOverhangs)
+
+      --preMergeChainSubThresh <PRE_MERGE_CHAIN_SUB_THRESH>
+          Per-target pre-merge chain sub-optimality threshold: keep chains scoring `>= best_chain_score * thresh` (selective-alignment mode). Range [0,1]. Rust default 0.8 (salmon's default is 0.75)
+          
+          [default: 0.8]
+
+      --postMergeChainSubThresh <POST_MERGE_CHAIN_SUB_THRESH>
+          Post-merge concordant chain-pair sub-optimality threshold: after pairing, keep pairs whose read-coverage is `>= best_pair_coverage * thresh` (paired-end, selective-alignment mode). Range [0,1]. Default 0.0 (off); salmon's default is 0.9, thresholded on chain score rather than coverage
+          
+          [default: 0]
+
+      --biasSpeedSamp <BIAS_SPEED_SAMP>
+          Fragment-length sampling stride for the GC bias eff-length convolution. Larger = faster bias correction, coarser. (salmon's --biasSpeedSamp)
+          
+          [default: 5]
+
+      --numAuxModelSamples <NUM_AUX_MODEL_SAMPLES>
+          Number of leading fragments used to train the auxiliary models (fragment-length / bias / error); they are fixed afterward
+          
+          [default: 5000000]
+
+      --noBiasLengthThreshold
+          Disable the lower threshold on how short bias correction may make an effective length (increases precision, reduces robustness). Experimental
+
+      --numErrorBins <NUM_ERROR_BINS>
+          Number of read-position bins in the alignment error model (alignment mode only). (salmon's --numErrorBins)
+          
+          [default: 4]
+
+      --numGCBins <NUM_GC_BINS>
+          Number of fragment-GC bins for the GC bias model. (salmon's --numGCBins)
+          
+          [default: 25]
+
+      --conditionalGCBins <CONDITIONAL_GC_BINS>
+          Number of conditioning (context) bins for the GC bias model. (salmon's --conditionalGCBins)
+          
+          [default: 3]
+
+      --discardOrphans
+          Discard orphan (single-mate) alignments in a paired library (alignment mode). Reads mode uses --discardOrphansQuasi
+
+      --mappingCacheMemoryLimit <MAPPING_CACHE_MEMORY_LIMIT>
+          [accepted for salmon compatibility; no effect] alignment-mode mapping cache size — the Rust align path streams with bounded buffers
+
+      --disableChainingHeuristic
+          [accepted for salmon compatibility; no effect] the Rust chainer uses a loss-less ref-distance early-break, not salmon's numRounds heuristic
+
+      --mismatchSeedSkip <MISMATCH_SEED_SKIP>
+          [accepted for salmon compatibility; no effect yet] bases to skip after a k-mer miss during seeding — lives in the piscem-rs seed-walk; not yet tunable
+
+      --reduceGCMemory
+          [accepted for salmon compatibility; now the default] the rank-bitvector GC representation it selects is used unconditionally — it is faster and ~2x leaner than the dense representation with identical results
+
+      --skipQuant
+          Skip transcript quantification (EM + Gibbs/bootstrap) and quant.sf, while still mapping, building equivalence classes (use with --dumpEq), detecting library type, and writing metadata. (salmon's --skipQuant)
+
+      --eqclasses <EQCLASSES>
+          [not yet implemented] quantify from a previously-written equivalence-class file instead of mapping/alignments (an input mode, not the --dumpEq output)
+
+      --numPreAuxModelSamples <NUM_PRE_AUX_MODEL_SAMPLES>
+          Fragments processed before the auxiliary (fragment-length) model is applied during online inference. (salmon's --numPreAuxModelSamples; salmon's default is 1000000, this port's is 5000.)
+          
+          [default: 5000]
+
+      --noFragLengthDist
+          [accepted; not yet implemented] disable fragment-length-distribution concordance in the per-fragment probability
+
+      --noSingleFragProb
+          [accepted; not yet implemented] disable the single-end/orphan fragment-length probability estimate
+
+  -s, --sampleOut
+          [accepted; not yet implemented] write a BAM of posterior-sampled alignments (alignment mode)
+
+  -u, --sampleUnaligned
+          [accepted; not yet implemented] also include unaligned reads in the sampled BAM (requires --sampleOut)
+
+      --writeQualities
+          [accepted; not yet implemented] write qualities into the sampled BAM (only meaningful with --sampleOut / --writeMappings)
+
+      --hitFilterPolicy <HIT_FILTER_POLICY>
+          [accepted; not yet implemented] hit-filtering policy (BEFORE/AFTER/BOTH/ NONE) for selective alignment; the Rust port filters after chaining
+
+      --maxRecoverReadOcc <MAX_RECOVER_READ_OCC>
+          [accepted; not yet implemented] cap on candidate mappings during orphan recovery (salmon's --maxRecoverReadOcc)
+
+      --validateMappings
+          [accepted; no effect] deprecated in salmon too — selective alignment is the default mapping mode (use --sketch for pseudoalignment)
+
+  -h, --help
+          Print help (see a summary with '-h')
diff --git a/tests/tool_audit/help/scyphy.txt b/tests/tool_audit/help/scyphy.txt
new file mode 100644
index 00000000..9f13b0f5
--- /dev/null
+++ b/tests/tool_audit/help/scyphy.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+FATAL:   "scyphy": executable file not found in $PATH
diff --git a/tests/tool_audit/help/segemehl3_help.txt b/tests/tool_audit/help/segemehl3_help.txt
new file mode 100644
index 00000000..d9cf1e7a
--- /dev/null
+++ b/tests/tool_audit/help/segemehl3_help.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+FATAL:   "segemehl3": executable file not found in $PATH
diff --git a/tests/tool_audit/help/segemehl_help.txt b/tests/tool_audit/help/segemehl_help.txt
new file mode 100644
index 00000000..cdb0889c
--- /dev/null
+++ b/tests/tool_audit/help/segemehl_help.txt
@@ -0,0 +1,109 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+usage: /opt/conda/envs/monsda/bin/segemehl.x 
+                    [-sbcKVTYCO] -d <file> [<file>] [-q <file>] 
+                    [-p <file>] [-i <file>] [-j <file>] 
+                    [-x <file>] [-y <file>] [-B <string>] [-F <n>] 
+                    [-m <n>] [-t <n>] [-o <string>] [-u <file>] 
+                    [-D <n>] [-J <n>] [-E <double>] [-w <double>] 
+                    [-M <n>] [-r <n>] [-S] [--nohead] [-e <n>] 
+                    [-n <n>] [-X <n>] [-A <n>] [-W <n>] [-U <n>] 
+                    
+                    [-Z <n>] [-l <f>] [-H] [--showalign] [-P <string>] [-Q <string>] [-R <n>] [-I <n>] 
+  Heuristic mapping of short sequences
+
+ [INPUT]                         
+ -d, --database <file> [<file>]  list of path/filename(s) of 
+                                 database sequence(s)
+ -q, --query <file>              path/filename of query sequences 
+                                 (default:none)
+ -p, --mate <file>               path/filename of mate pair 
+                                 sequences (default:none)
+ -i, --index <file>              path/filename of db index 
+                                 (default:none)
+ -j, --index2 <file>             path/filename of second db index 
+                                 (default:none)
+ -x, --generate <file>           generate db index and store to disk 
+                                 (default:none)
+ -y, --generate2 <file>          generate second db index and store 
+                                 to disk (default:none)
+ -B, --filebins <string>         file bins with basename <string> 
+                                 for easier data handling 
+                                 (default:none)
+ -F, --bisulfite <n>             bisulfite mapping with 
+                                 methylC-seq/Lister et al. (=1) or 
+                                 bs-seq/Cokus et al. protocol (=2) 
+                                 (default:0)
+ [GENERAL]                       
+ -m, --minsize <n>               minimum size of queries (default:12)
+ -s, --silent                    shut up!
+ -b, --brief                     brief output
+ -c, --checkidx                  check index
+ -t, --threads <n>               start <n> threads (default:1)
+ -o, --outfile <string>          outputfile (default:none)
+ -u, --nomatchfilename <file>    filename for unmatched reads 
+                                 (default:none)
+ [SEEDPARAMS]                    
+ -D, --differences <n>           search seeds initially with <n> 
+                                 differences (default:1)
+ -J, --jump <n>                  search seeds with jump size <n> 
+                                 (0=automatic) (default:0)
+ -E, --evalue <double>           max evalue (default:5.000000)
+ -w, --maxsplitevalue <double>   max evalue for splits 
+                                 (default:50.000000)
+ -M, --maxinterval <n>           maximum width of a suffix array 
+                                 interval, i.e. a query seed will 
+                                 be omitted if it matches more 
+                                 than <n> times (default:100)
+ -r, --maxout <n>                maximum number of alignments that 
+                                 will be reported. If set to zero, 
+                                 all alignments will be reported 
+                                 (default:0)
+ -S, --splits                    detect split/spliced reads 
+                                 (default:none)
+ -K, --SEGEMEHL                  output SEGEMEHL format (needs to be 
+                                 selected for brief)
+ -V, --MEOP                      output MEOP field for easier 
+                                 variance calling in SAM (XE:Z:)
+ --nohead                        do not output header
+ [SEEDEXTENSIONPARAMS]           
+ -e, --extensionscore <n>        score of a match during extension 
+                                 (default:2)
+ -n, --extensionpenalty <n>      penalty for a mismatch during 
+                                 extension (default:4)
+ -X, --dropoff <n>               dropoff parameter for extension 
+                                 (default:8)
+ [ALIGNPARAMS]                   
+ -A, --accuracy <n>              min percentage of matches per read 
+                                 in semi-global alignment 
+                                 (default:90)
+ -W, --minsplicecover <n>        min coverage for spliced 
+                                 transcripts (default:80)
+ -U, --minfragscore <n>          min score of a spliced fragment 
+                                 (default:18)
+ -Z, --minfraglen <n>            min length of a spliced fragment 
+                                 (default:20)
+ -l, --splicescorescale <f>      report spliced alignment with score 
+                                 s only if <f>*s is larger than 
+                                 next best spliced alignment 
+                                 (default:1.000000)
+ -H, --hitstrategy               report only best scoring hits (=1) 
+                                 or all (=0) (default:1)
+ --showalign                     show alignments
+ -P, --prime5 <string>           add 5' adapter (default:none)
+ -Q, --prime3 <string>           add 3' adapter (default:none)
+ -R, --clipacc <n>               clipping accuracy (default:70)
+ -T, --polyA                     clip polyA tail
+ -Y, --autoclip                  autoclip unknown 3prime adapter
+ -C, --hardclip                  enable hard clipping
+ -O, --order                     sorts the output by chromsome and 
+                                 position (might take a while!)
+ -I, --maxinsertsize <n>         maximum size of the inserts (paired 
+                                 end) (default:5000)
+ [VERSION]
+  0.2.0-418 (2015-01-05 05:17:35 -0500 (Mon, 05 Jan 2015))
+ [BUGS]
+  Please report bugs to steve@bioinf.uni-leipzig.de
+ [REFERENCES]
+  SEGEMEHL is free software for non-commercial use 
+  (C) 2008 Bioinformatik Leipzig
+
diff --git a/tests/tool_audit/help/simpleaf.txt b/tests/tool_audit/help/simpleaf.txt
new file mode 100644
index 00000000..69001cc0
--- /dev/null
+++ b/tests/tool_audit/help/simpleaf.txt
@@ -0,0 +1,2 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Error: $ALEVIN_FRY_HOME is unset environment variable not found, please set this environment variable to continue.
diff --git a/tests/tool_audit/help/sra.txt b/tests/tool_audit/help/sra.txt
new file mode 100644
index 00000000..66471f22
--- /dev/null
+++ b/tests/tool_audit/help/sra.txt
@@ -0,0 +1,71 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+Usage:
+  fasterq-dump <path> [options]
+  fasterq-dump <accession> [options]
+
+Options:
+  -F|--format                      format (special, fastq, default=fastq) 
+  -o|--outfile                     output-file 
+  -O|--outdir                      output-dir 
+  -b|--bufsize                     size of file-buffer dflt=1MB 
+  -c|--curcache                    size of cursor-cache dflt=10MB 
+  -m|--mem                         memory limit for sorting dflt=100MB 
+  -t|--temp                        where to put temp. files dflt=curr dir 
+  -e|--threads                     how many thread dflt=6 
+  -p|--progress                    show progress 
+  -x|--details                     print details 
+  -s|--split-spot                  split spots into reads 
+  -S|--split-files                 write reads into different files 
+  -3|--split-3                     writes single reads in special file 
+  --concatenate-reads              writes whole spots into one file 
+  -Z|--stdout                      print output to stdout 
+  -f|--force                       force to overwrite existing file(s) 
+  --skip-technical                 skip technical reads 
+  --include-technical              include technical reads 
+  -M|--min-read-len                filter by sequence-len 
+  --table                          which seq-table to use in case of pacbio 
+  -B|--bases                       filter by bases 
+  -A|--append                      append to output-file 
+  --fasta                          produce FASTA output 
+  --fasta-unsorted                 produce FASTA output, unsorted 
+  --fasta-ref-tbl                  produce FASTA output from REFERENCE tbl 
+  --fasta-concat-all               concatenate all rows and produce FASTA 
+  --internal-ref                   extract only internal REFERENCEs 
+  --external-ref                   extract only external REFERENCEs 
+  --ref-name                       extract only these REFERENCEs 
+  --ref-report                     enumerate references 
+  --use-name                       print name instead of seq-id 
+  --seq-defline                    custom defline for sequence:  $ac=accession, 
+                                   $sn=spot-name,  $sg=spot-group, $si=spot-id,  
+                                   $ri=read-id, $rl=read-length 
+  --qual-defline                   custom defline for qualities:  same as 
+                                   seq-defline 
+  -U|--only-unaligned              process only unaligned reads 
+  -a|--only-aligned                process only aligned reads 
+  --disk-limit                     explicitly set disk-limit 
+  --disk-limit-tmp                 explicitly set disk-limit for temp. files 
+  --size-check                     switch to control: on=perform size-check 
+                                   (default),  off=do not perform size-check,  
+                                   only=perform size-check only 
+  --ngc <PATH>                     PATH to ngc file 
+
+  -h|--help                        Output brief explanation for the program. 
+  -V|--version                     Display the version of the program then 
+                                   quit. 
+  -L|--log-level <level>           Logging level as number or enum string. One 
+                                   of (fatal|sys|int|err|warn|info|debug) or 
+                                   (0-6) Current/default is warn. 
+  -v|--verbose                     Increase the verbosity of the program 
+                                   status messages. Use multiple times for more 
+                                   verbosity. Negates quiet. 
+  -q|--quiet                       Turn off all status messages for the 
+                                   program. Negated by verbose. 
+  --option-file <file>             Read more options and parameters from the 
+                                   file. 
+for more information visit:
+   https://github.com/ncbi/sra-tools/wiki/HowTo:-fasterq-dump
+   https://github.com/ncbi/sra-tools/wiki/08.-prefetch-and-fasterq-dump
+
+/opt/conda/envs/monsda/bin/fasterq-dump : 3.2.0
+
diff --git a/tests/tool_audit/help/sra_help.txt b/tests/tool_audit/help/sra_help.txt
new file mode 100644
index 00000000..66471f22
--- /dev/null
+++ b/tests/tool_audit/help/sra_help.txt
@@ -0,0 +1,71 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+Usage:
+  fasterq-dump <path> [options]
+  fasterq-dump <accession> [options]
+
+Options:
+  -F|--format                      format (special, fastq, default=fastq) 
+  -o|--outfile                     output-file 
+  -O|--outdir                      output-dir 
+  -b|--bufsize                     size of file-buffer dflt=1MB 
+  -c|--curcache                    size of cursor-cache dflt=10MB 
+  -m|--mem                         memory limit for sorting dflt=100MB 
+  -t|--temp                        where to put temp. files dflt=curr dir 
+  -e|--threads                     how many thread dflt=6 
+  -p|--progress                    show progress 
+  -x|--details                     print details 
+  -s|--split-spot                  split spots into reads 
+  -S|--split-files                 write reads into different files 
+  -3|--split-3                     writes single reads in special file 
+  --concatenate-reads              writes whole spots into one file 
+  -Z|--stdout                      print output to stdout 
+  -f|--force                       force to overwrite existing file(s) 
+  --skip-technical                 skip technical reads 
+  --include-technical              include technical reads 
+  -M|--min-read-len                filter by sequence-len 
+  --table                          which seq-table to use in case of pacbio 
+  -B|--bases                       filter by bases 
+  -A|--append                      append to output-file 
+  --fasta                          produce FASTA output 
+  --fasta-unsorted                 produce FASTA output, unsorted 
+  --fasta-ref-tbl                  produce FASTA output from REFERENCE tbl 
+  --fasta-concat-all               concatenate all rows and produce FASTA 
+  --internal-ref                   extract only internal REFERENCEs 
+  --external-ref                   extract only external REFERENCEs 
+  --ref-name                       extract only these REFERENCEs 
+  --ref-report                     enumerate references 
+  --use-name                       print name instead of seq-id 
+  --seq-defline                    custom defline for sequence:  $ac=accession, 
+                                   $sn=spot-name,  $sg=spot-group, $si=spot-id,  
+                                   $ri=read-id, $rl=read-length 
+  --qual-defline                   custom defline for qualities:  same as 
+                                   seq-defline 
+  -U|--only-unaligned              process only unaligned reads 
+  -a|--only-aligned                process only aligned reads 
+  --disk-limit                     explicitly set disk-limit 
+  --disk-limit-tmp                 explicitly set disk-limit for temp. files 
+  --size-check                     switch to control: on=perform size-check 
+                                   (default),  off=do not perform size-check,  
+                                   only=perform size-check only 
+  --ngc <PATH>                     PATH to ngc file 
+
+  -h|--help                        Output brief explanation for the program. 
+  -V|--version                     Display the version of the program then 
+                                   quit. 
+  -L|--log-level <level>           Logging level as number or enum string. One 
+                                   of (fatal|sys|int|err|warn|info|debug) or 
+                                   (0-6) Current/default is warn. 
+  -v|--verbose                     Increase the verbosity of the program 
+                                   status messages. Use multiple times for more 
+                                   verbosity. Negates quiet. 
+  -q|--quiet                       Turn off all status messages for the 
+                                   program. Negated by verbose. 
+  --option-file <file>             Read more options and parameters from the 
+                                   file. 
+for more information visit:
+   https://github.com/ncbi/sra-tools/wiki/HowTo:-fasterq-dump
+   https://github.com/ncbi/sra-tools/wiki/08.-prefetch-and-fasterq-dump
+
+/opt/conda/envs/monsda/bin/fasterq-dump : 3.2.0
+
diff --git a/tests/tool_audit/help/star.txt b/tests/tool_audit/help/star.txt
new file mode 100644
index 00000000..9418afb3
--- /dev/null
+++ b/tests/tool_audit/help/star.txt
@@ -0,0 +1,928 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Usage: STAR  [options]... --genomeDir /path/to/genome/index/   --readFilesIn R1.fq R2.fq
+Spliced Transcripts Alignment to a Reference (c) Alexander Dobin, 2009-2022
+
+STAR version=2.7.11b
+STAR compilation time,server,dir=2025-11-14T12:06:42+0000 :/opt/conda/conda-bld/star_1763121846936/work/source
+For more details see:
+<https://github.com/alexdobin/STAR>
+<https://github.com/alexdobin/STAR/blob/master/doc/STARmanual.pdf>
+### versions
+versionGenome           2.7.4a
+    string: earliest genome index version compatible with this STAR release. Please do not change this value!
+
+### Parameter Files
+parametersFiles          -
+    string: name of a user-defined parameters file, "-": none. Can only be defined on the command line.
+
+### System
+sysShell            -
+    string: path to the shell binary, preferably bash, e.g. /bin/bash.
+                    - ... the default shell is executed, typically /bin/sh. This was reported to fail on some Ubuntu systems - then you need to specify path to bash.
+
+### Run Parameters
+runMode                         alignReads
+    string: type of the run.
+                                alignReads             ... map reads
+                                genomeGenerate         ... generate genome files
+                                inputAlignmentsFromBAM ... input alignments from BAM. Presently only works with --outWigType and --bamRemoveDuplicates options.
+                                liftOver               ... lift-over of GTF files (--sjdbGTFfile) between genome assemblies using chain file(s) from --genomeChainFiles.
+                                soloCellFiltering  </path/to/raw/count/dir/>   </path/to/output/prefix>    ... STARsolo cell filtering ("calling") without remapping, followed by the path to raw count directory and output (filtered) prefix
+
+runThreadN                      1
+    int: number of threads to run STAR
+
+runDirPerm                      User_RWX
+    string: permissions for the directories created at the run-time.
+                                User_RWX ... user-read/write/execute
+                                All_RWX  ... all-read/write/execute (same as chmod 777)
+
+runRNGseed                      777
+    int: random number generator seed.
+
+
+### Genome Parameters
+genomeDir                   ./GenomeDir/
+    string: path to the directory where genome files are stored (for --runMode alignReads) or will be generated (for --runMode generateGenome)
+
+genomeLoad                NoSharedMemory
+    string: mode of shared memory usage for the genome files. Only used with --runMode alignReads.
+                          LoadAndKeep     ... load genome into shared and keep it in memory after run
+                          LoadAndRemove   ... load genome into shared but remove it after run
+                          LoadAndExit     ... load genome into shared memory and exit, keeping the genome in memory for future runs
+                          Remove          ... do not map anything, just remove loaded genome from memory
+                          NoSharedMemory  ... do not use shared memory, each job will have its own private copy of the genome
+
+genomeFastaFiles            -
+    string(s): path(s) to the fasta files with the genome sequences, separated by spaces. These files should be plain text FASTA files, they *cannot* be zipped.
+                            Required for the genome generation (--runMode genomeGenerate). Can also be used in the mapping (--runMode alignReads) to add extra (new) sequences to the genome (e.g. spike-ins).
+
+genomeChainFiles            -
+    string: chain files for genomic liftover. Only used with --runMode liftOver .
+
+genomeFileSizes             0
+    uint(s)>0: genome files exact sizes in bytes. Typically, this should not be defined by the user.
+    
+genomeTransformOutput       None
+    string(s):              which output to transform back to original genome
+                            SAM     ... SAM/BAM alignments
+                            SJ      ... splice junctions (SJ.out.tab)
+                            Quant   ... quantifications (from --quantMode option)
+                            None    ... no transformation of the output        
+
+genomeChrSetMitochondrial   chrM M MT
+    string(s):              names of the mitochondrial chromosomes. Presently only used for STARsolo statistics output/
+
+### Genome Indexing Parameters - only used with --runMode genomeGenerate
+genomeChrBinNbits           18
+    int: =log2(chrBin), where chrBin is the size of the bins for genome storage: each chromosome will occupy an integer number of bins. For a genome with large number of contigs, it is recommended to scale this parameter as min(18, log2[max(GenomeLength/NumberOfReferences,ReadLength)]).
+
+genomeSAindexNbases         14
+    int: length (bases) of the SA pre-indexing string. Typically between 10 and 15. Longer strings will use much more memory, but allow faster searches. For small genomes, the parameter --genomeSAindexNbases must be scaled down to min(14, log2(GenomeLength)/2 - 1).
+
+genomeSAsparseD             1
+    int>0: suffux array sparsity, i.e. distance between indices: use bigger numbers to decrease needed RAM at the cost of mapping speed reduction
+
+genomeSuffixLengthMax       -1
+    int: maximum length of the suffixes, has to be longer than read length. -1 = infinite.
+    
+genomeTransformType         None
+    string: type of genome transformation
+                            None       ... no transformation
+                            Haploid    ... replace reference alleles with alternative alleles from VCF file (e.g. consensus allele)
+                            Diploid    ... create two haplotypes for each chromosome listed in VCF file, for genotypes 1|2, assumes perfect phasing (e.g. personal genome)
+
+genomeTransformVCF          -
+    string: path to VCF file for genome transformation
+
+
+    
+#####UnderDevelopment_begin : not supported - do not use
+genomeType                  Full
+    string: type of genome to generate
+                            Full                ... full (normal) genome
+                            Transcriptome       ... genome consists of transcript sequences
+                            SuperTransriptome   ... genome consists of superTranscript sequences
+#####UnderDevelopment_end
+
+# DEPRECATED: please use --genomeTransformVCF and --genomeTransformType options instead.
+#genomeConsensusFile         -
+#    string: VCF file with consensus SNPs (i.e. alternative allele is the major (AF>0.5) allele)
+# DEPRECATED 
+
+
+
+### Splice Junctions Database
+sjdbFileChrStartEnd                     -
+    string(s): path to the files with genomic coordinates (chr <tab> start <tab> end <tab> strand) for the splice junction introns. Multiple files can be supplied and will be concatenated.
+
+sjdbGTFfile                             -
+    string: path to the GTF file with annotations
+
+sjdbGTFchrPrefix                        -
+    string: prefix for chromosome names in a GTF file (e.g. 'chr' for using ENSMEBL annotations with UCSC genomes)
+
+sjdbGTFfeatureExon                      exon
+    string: feature type in GTF file to be used as exons for building transcripts
+
+sjdbGTFtagExonParentTranscript          transcript_id
+    string: GTF attribute name for parent transcript ID (default "transcript_id" works for GTF files)
+
+sjdbGTFtagExonParentGene                gene_id
+    string: GTF attribute name for parent gene ID (default "gene_id" works for GTF files)
+
+sjdbGTFtagExonParentGeneName            gene_name
+    string(s): GTF attribute name for parent gene name
+
+sjdbGTFtagExonParentGeneType            gene_type gene_biotype
+    string(s): GTF attribute name for parent gene type
+
+sjdbOverhang                            100
+    int>0: length of the donor/acceptor sequence on each side of the junctions, ideally = (mate_length - 1)
+
+sjdbScore                               2
+    int: extra alignment score for alignments that cross database junctions
+
+sjdbInsertSave                          Basic
+    string: which files to save when sjdb junctions are inserted on the fly at the mapping step
+                    Basic ... only small junction / transcript files
+                    All   ... all files including big Genome, SA and SAindex - this will create a complete genome directory
+
+### Variation parameters
+varVCFfile                              -
+    string: path to the VCF file that contains variation data. The 10th column should contain the genotype information, e.g. 0/1
+
+### Input Files
+inputBAMfile                -
+    string: path to BAM input file, to be used with --runMode inputAlignmentsFromBAM
+
+### Read Parameters
+readFilesType               Fastx
+    string: format of input read files
+                            Fastx       ... FASTA or FASTQ
+                            SAM SE      ... SAM or BAM single-end reads; for BAM use --readFilesCommand samtools view
+                            SAM PE      ... SAM or BAM paired-end reads; for BAM use --readFilesCommand samtools view
+                            
+readFilesSAMattrKeep        All
+    string(s): for --readFilesType SAM SE/PE, which SAM tags to keep in the output BAM, e.g.: --readFilesSAMtagsKeep RG PL
+                            All     ... keep all tags
+                            None    ... do not keep any tags
+
+readFilesIn                 Read1 Read2
+    string(s): paths to files that contain input read1 (and, if needed,  read2)
+
+readFilesManifest           -
+    string: path to the "manifest" file with the names of read files. The manifest file should contain 3 tab-separated columns:
+            paired-end reads: read1_file_name $tab$ read2_file_name $tab$ read_group_line.
+            single-end reads: read1_file_name $tab$ -               $tab$ read_group_line.
+            Spaces, but not tabs are allowed in file names.
+            If read_group_line does not start with ID:, it can only contain one ID field, and ID: will be added to it.
+            If read_group_line starts with ID:, it can contain several fields separated by $tab$, and all fields will be be copied verbatim into SAM @RG header line.
+
+readFilesPrefix             -
+    string: prefix for the read files names, i.e. it will be added in front of the strings in --readFilesIn
+
+readFilesCommand             -
+    string(s): command line to execute for each of the input file. This command should generate FASTA or FASTQ text and send it to stdout
+               For example: zcat - to uncompress .gz files, bzcat - to uncompress .bz2 files, etc.
+
+readMapNumber               -1
+    int: number of reads to map from the beginning of the file
+                            -1: map all reads
+
+readMatesLengthsIn          NotEqual
+    string: Equal/NotEqual - lengths of names,sequences,qualities for both mates are the same  / not the same. NotEqual is safe in all situations.
+
+readNameSeparator           /
+    string(s): character(s) separating the part of the read names that will be trimmed in output (read name after space is always trimmed)
+
+readQualityScoreBase        33
+    int>=0: number to be subtracted from the ASCII code to get Phred quality score
+
+### Read Clipping
+
+clipAdapterType             Hamming
+    string:                 adapter clipping type
+                            Hamming ... adapter clipping based on Hamming distance, with the number of mismatches controlled by --clip5pAdapterMMp
+                            CellRanger4 ... 5p and 3p adapter clipping similar to CellRanger4. Utilizes Opal package by Martin Šošić: https://github.com/Martinsos/opal
+                            None ... no adapter clipping, all other clip* parameters are disregarded
+                            
+clip3pNbases                 0
+    int(s): number(s) of bases to clip from 3p of each mate. If one value is given, it will be assumed the same for both mates.
+
+clip3pAdapterSeq            -
+    string(s): adapter sequences to clip from 3p of each mate.  If one value is given, it will be assumed the same for both mates.
+                            polyA ... polyA sequence with the length equal to read length
+
+clip3pAdapterMMp            0.1
+    double(s): max proportion of mismatches for 3p adapter clipping for each mate.  If one value is given, it will be assumed the same for both mates.
+
+clip3pAfterAdapterNbases    0
+    int(s): number of bases to clip from 3p of each mate after the adapter clipping. If one value is given, it will be assumed the same for both mates.
+
+clip5pNbases                 0
+    int(s): number(s) of bases to clip from 5p of each mate. If one value is given, it will be assumed the same for both mates.
+
+#####UnderDevelopment_begin : not supported - do not use   
+clip5pAdapterSeq            -
+    string(s): adapter sequences to clip from 5p of each mate, separated by space.
+
+clip5pAdapterMMp            0.1
+    double(s): max proportion of mismatches for 5p adapter clipping for each mate, separated by space
+
+clip5pAfterAdapterNbases    0
+    int(s): number of bases to clip from 5p of each mate after the adapter clipping, separated by space.
+#####UnderDevelopment_end
+
+### Limits
+limitGenomeGenerateRAM               31000000000
+    int>0: maximum available RAM (bytes) for genome generation
+
+limitIObufferSize                    30000000 50000000
+    int(s)>0: max available buffers size (bytes) for input/output, per thread
+
+limitOutSAMoneReadBytes              100000
+    int>0: max size of the SAM record (bytes) for one read. Recommended value: >(2*(LengthMate1+LengthMate2+100)*outFilterMultimapNmax
+
+limitOutSJoneRead                    1000
+    int>0: max number of junctions for one read (including all multi-mappers)
+
+limitOutSJcollapsed                  1000000
+    int>0: max number of collapsed junctions
+
+limitBAMsortRAM                         0
+    int>=0: maximum available RAM (bytes) for sorting BAM. If =0, it will be set to the genome index size. 0 value can only be used with --genomeLoad NoSharedMemory option.
+
+limitSjdbInsertNsj                     1000000
+    int>=0: maximum number of junctions to be inserted to the genome on the fly at the mapping stage, including those from annotations and those detected in the 1st step of the 2-pass run
+
+limitNreadsSoft                        -1
+    int: soft limit on the number of reads
+
+### Output: general
+outFileNamePrefix               ./
+    string: output files name prefix (including full or relative path). Can only be defined on the command line.
+
+outTmpDir                       -
+    string: path to a directory that will be used as temporary by STAR. All contents of this directory will be removed!
+                                - ... the temp directory will default to outFileNamePrefix_STARtmp
+
+outTmpKeep                      None
+    string: whether to keep the temporary files after STAR runs is finished
+                                None ... remove all temporary files
+                                All ... keep all files
+
+outStd                          Log
+    string: which output will be directed to stdout (standard out)
+                                Log                    ... log messages
+                                SAM                    ... alignments in SAM format (which normally are output to Aligned.out.sam file), normal standard output will go into Log.std.out
+                                BAM_Unsorted           ... alignments in BAM format, unsorted. Requires --outSAMtype BAM Unsorted
+                                BAM_SortedByCoordinate ... alignments in BAM format, sorted by coordinate. Requires --outSAMtype BAM SortedByCoordinate
+                                BAM_Quant              ... alignments to transcriptome in BAM format, unsorted. Requires --quantMode TranscriptomeSAM
+
+outReadsUnmapped                None
+   string: output of unmapped and partially mapped (i.e. mapped only one mate of a paired end read) reads in separate file(s).
+                                None    ... no output
+                                Fastx   ... output in separate fasta/fastq files, Unmapped.out.mate1/2
+
+outQSconversionAdd              0
+   int: add this number to the quality score (e.g. to convert from Illumina to Sanger, use -31)
+
+outMultimapperOrder             Old_2.4
+    string: order of multimapping alignments in the output files
+                                Old_2.4             ... quasi-random order used before 2.5.0
+                                Random              ... random order of alignments for each multi-mapper. Read mates (pairs) are always adjacent, all alignment for each read stay together. This option will become default in the future releases.
+
+### Output: SAM and BAM
+outSAMtype                      SAM
+    strings: type of SAM/BAM output
+                                1st word:
+                                BAM  ... output BAM without sorting
+                                SAM  ... output SAM without sorting
+                                None ... no SAM/BAM output
+                                2nd, 3rd:
+                                Unsorted           ... standard unsorted
+                                SortedByCoordinate ... sorted by coordinate. This option will allocate extra memory for sorting which can be specified by --limitBAMsortRAM.
+
+outSAMmode                      Full
+    string: mode of SAM output
+                                None ... no SAM output
+                                Full ... full SAM output
+                                NoQS ... full SAM but without quality scores
+
+outSAMstrandField               None
+    string: Cufflinks-like strand field flag
+                                None        ... not used
+                                intronMotif ... strand derived from the intron motif. This option changes the output alignments: reads with inconsistent and/or non-canonical introns are filtered out.
+
+outSAMattributes                Standard
+    string(s): a string of desired SAM attributes, in the order desired for the output SAM. Tags can be listed in any combination/order.
+                                ***Presets:
+                                None        ... no attributes
+                                Standard    ... NH HI AS nM
+                                All         ... NH HI AS nM NM MD jM jI MC ch                                                                    
+                                ***Alignment:
+                                NH          ... number of loci the reads maps to: =1 for unique mappers, >1 for multimappers. Standard SAM tag.
+                                HI          ... multiple alignment index, starts with --outSAMattrIHstart (=1 by default). Standard SAM tag.
+                                AS          ... local alignment score, +1/-1 for matches/mismateches, score* penalties for indels and gaps. For PE reads, total score for two mates. Stadnard SAM tag.
+                                nM          ... number of mismatches. For PE reads, sum over two mates.
+                                NM          ... edit distance to the reference (number of mismatched + inserted + deleted bases) for each mate. Standard SAM tag.
+                                MD          ... string encoding mismatched and deleted reference bases (see standard SAM specifications). Standard SAM tag.
+                                jM          ... intron motifs for all junctions (i.e. N in CIGAR): 0: non-canonical; 1: GT/AG, 2: CT/AC, 3: GC/AG, 4: CT/GC, 5: AT/AC, 6: GT/AT. If splice junctions database is used, and a junction is annotated, 20 is added to its motif value.
+                                jI          ... start and end of introns for all junctions (1-based).
+                                XS          ... alignment strand according to --outSAMstrandField.
+                                MC          ... mate's CIGAR string. Standard SAM tag.
+                                ch          ... marks all segment of all chimeric alingments for --chimOutType WithinBAM output.
+                                cN          ... number of bases clipped from the read ends: 5' and 3'
+                                ***Variation:
+                                vA          ... variant allele
+                                vG          ... genomic coordinate of the variant overlapped by the read.
+                                vW          ... 1 - alignment passes WASP filtering; 2,3,4,5,6,7 - alignment does not pass WASP filtering. Requires --waspOutputMode SAMtag.
+                                ha          ... haplotype (1/2) when mapping to the diploid genome. Requires genome generated with --genomeTransformType Diploid .                               
+                                ***STARsolo:
+                                CR CY UR UY ... sequences and quality scores of cell barcodes and UMIs for the solo* demultiplexing.
+                                GX GN       ... gene ID and gene name for unique-gene reads.
+                                gx gn       ... gene IDs and gene names for unique- and multi-gene reads.
+                                CB UB       ... error-corrected cell barcodes and UMIs for solo* demultiplexing. Requires --outSAMtype BAM SortedByCoordinate.
+                                sM          ... assessment of CB and UMI.
+                                sS          ... sequence of the entire barcode (CB,UMI,adapter).
+                                sQ          ... quality of the entire barcode.
+                                sF          ... type of feature overlap and number of features for each alignment
+                                ***Unsupported/undocumented:
+                                rB          ... alignment block read/genomic coordinates.
+                                vR          ... read coordinate of the variant.
+
+outSAMattrIHstart               1
+    int>=0:                     start value for the IH attribute. 0 may be required by some downstream software, such as Cufflinks or StringTie.
+
+outSAMunmapped                  None
+    string(s): output of unmapped reads in the SAM format
+                                1st word:
+                                None   ... no output
+                                Within ... output unmapped reads within the main SAM file (i.e. Aligned.out.sam)
+                                2nd word:
+                                KeepPairs ... record unmapped mate for each alignment, and, in case of unsorted output, keep it adjacent to its mapped mate. Only affects multi-mapping reads.
+
+outSAMorder                     Paired
+    string: type of sorting for the SAM output
+                                Paired: one mate after the other for all paired alignments
+                                PairedKeepInputOrder: one mate after the other for all paired alignments, the order is kept the same as in the input FASTQ files
+
+outSAMprimaryFlag        OneBestScore
+    string: which alignments are considered primary - all others will be marked with 0x100 bit in the FLAG
+                                OneBestScore ... only one alignment with the best score is primary
+                                AllBestScore ... all alignments with the best score are primary
+
+outSAMreadID            Standard
+    string: read ID record type
+                                Standard ... first word (until space) from the FASTx read ID line, removing /1,/2 from the end
+                                Number   ... read number (index) in the FASTx file
+
+outSAMmapqUnique        255
+    int: 0 to 255: the MAPQ value for unique mappers
+
+outSAMflagOR           0
+    int: 0 to 65535: sam FLAG will be bitwise OR'd with this value, i.e. FLAG=FLAG | outSAMflagOR. This is applied after all flags have been set by STAR, and after outSAMflagAND. Can be used to set specific bits that are not set otherwise.
+
+outSAMflagAND           65535
+    int: 0 to 65535: sam FLAG will be bitwise AND'd with this value, i.e. FLAG=FLAG & outSAMflagOR. This is applied after all flags have been set by STAR, but before outSAMflagOR. Can be used to unset specific bits that are not set otherwise.
+
+outSAMattrRGline        -
+    string(s): SAM/BAM read group line. The first word contains the read group identifier and must start with "ID:", e.g. --outSAMattrRGline ID:xxx CN:yy "DS:z z z".
+            xxx will be added as RG tag to each output alignment. Any spaces in the tag values have to be double quoted.
+            Comma separated RG lines correspons to different (comma separated) input files in --readFilesIn. Commas have to be surrounded by spaces, e.g.
+            --outSAMattrRGline ID:xxx , ID:zzz "DS:z z" , ID:yyy DS:yyyy
+
+outSAMheaderHD          -
+    strings: @HD (header) line of the SAM header
+
+outSAMheaderPG          -
+    strings: extra @PG (software) line of the SAM header (in addition to STAR)
+
+outSAMheaderCommentFile -
+    string: path to the file with @CO (comment) lines of the SAM header
+
+outSAMfilter            None
+    string(s): filter the output into main SAM/BAM files
+                        KeepOnlyAddedReferences ... only keep the reads for which all alignments are to the extra reference sequences added with --genomeFastaFiles at the mapping stage.
+                        KeepAllAddedReferences ...  keep all alignments to the extra reference sequences added with --genomeFastaFiles at the mapping stage.
+
+
+outSAMmultNmax          -1
+    int: max number of multiple alignments for a read that will be output to the SAM/BAM files. Note that if this value is not equal to -1, the top scoring alignment will be output first
+                        -1 ... all alignments (up to --outFilterMultimapNmax) will be output
+
+outSAMtlen              1
+    int: calculation method for the TLEN field in the SAM/BAM files
+                        1 ... leftmost base of the (+)strand mate to rightmost base of the (-)mate. (+)sign for the (+)strand mate
+                        2 ... leftmost base of any mate to rightmost base of any mate. (+)sign for the mate with the leftmost base. This is different from 1 for overlapping mates with protruding ends
+
+outBAMcompression       1
+    int: -1 to 10  BAM compression level, -1=default compression (6?), 0=no compression, 10=maximum compression
+
+outBAMsortingThreadN    0
+    int: >=0: number of threads for BAM sorting. 0 will default to min(6,--runThreadN).
+
+outBAMsortingBinsN      50
+    int: >0:  number of genome bins for coordinate-sorting
+
+### BAM processing
+bamRemoveDuplicatesType  -
+    string: mark duplicates in the BAM file, for now only works with (i) sorted BAM fed with inputBAMfile, and (ii) for paired-end alignments only
+                        -                       ... no duplicate removal/marking
+                        UniqueIdentical         ... mark all multimappers, and duplicate unique mappers. The coordinates, FLAG, CIGAR must be identical
+                        UniqueIdenticalNotMulti  ... mark duplicate unique mappers but not multimappers.
+
+bamRemoveDuplicatesMate2basesN   0
+    int>0: number of bases from the 5' of mate 2 to use in collapsing (e.g. for RAMPAGE)
+
+### Output Wiggle
+outWigType          None
+    string(s): type of signal output, e.g. "bedGraph" OR "bedGraph read1_5p". Requires sorted BAM: --outSAMtype BAM SortedByCoordinate .
+                    1st word:
+                    None       ... no signal output
+                    bedGraph   ... bedGraph format
+                    wiggle     ... wiggle format
+                    2nd word:
+                    read1_5p   ... signal from only 5' of the 1st read, useful for CAGE/RAMPAGE etc
+                    read2      ... signal from only 2nd read
+
+outWigStrand        Stranded
+    string: strandedness of wiggle/bedGraph output
+                    Stranded   ...  separate strands, str1 and str2
+                    Unstranded ...  collapsed strands
+
+outWigReferencesPrefix    -
+    string: prefix matching reference names to include in the output wiggle file, e.g. "chr", default "-" - include all references
+
+outWigNorm              RPM
+    string: type of normalization for the signal
+                        RPM    ... reads per million of mapped reads
+                        None   ... no normalization, "raw" counts
+
+### Output Filtering
+outFilterType                   Normal
+    string: type of filtering
+                                Normal  ... standard filtering using only current alignment
+                                BySJout ... keep only those reads that contain junctions that passed filtering into SJ.out.tab
+
+outFilterMultimapScoreRange     1
+    int: the score range below the maximum score for multimapping alignments
+
+outFilterMultimapNmax           10
+    int: maximum number of loci the read is allowed to map to. Alignments (all of them) will be output only if the read maps to no more loci than this value.
+         Otherwise no alignments will be output, and the read will be counted as "mapped to too many loci" in the Log.final.out .
+
+outFilterMismatchNmax           10
+    int: alignment will be output only if it has no more mismatches than this value.
+
+outFilterMismatchNoverLmax      0.3
+    real: alignment will be output only if its ratio of mismatches to *mapped* length is less than or equal to this value.
+
+outFilterMismatchNoverReadLmax  1.0
+    real: alignment will be output only if its ratio of mismatches to *read* length is less than or equal to this value.
+
+
+outFilterScoreMin               0
+    int: alignment will be output only if its score is higher than or equal to this value.
+
+outFilterScoreMinOverLread      0.66
+    real: same as outFilterScoreMin, but normalized to read length (sum of mates' lengths for paired-end reads)
+
+outFilterMatchNmin              0
+    int: alignment will be output only if the number of matched bases is higher than or equal to this value.
+
+outFilterMatchNminOverLread     0.66
+    real: sam as outFilterMatchNmin, but normalized to the read length (sum of mates' lengths for paired-end reads).
+
+outFilterIntronMotifs           None
+    string: filter alignment using their motifs
+                None                           ... no filtering
+                RemoveNoncanonical             ... filter out alignments that contain non-canonical junctions
+                RemoveNoncanonicalUnannotated  ... filter out alignments that contain non-canonical unannotated junctions when using annotated splice junctions database. The annotated non-canonical junctions will be kept.
+
+outFilterIntronStrands          RemoveInconsistentStrands
+    string: filter alignments
+                RemoveInconsistentStrands      ... remove alignments that have junctions with inconsistent strands
+                None                           ... no filtering
+
+### Output splice junctions (SJ.out.tab)
+outSJtype                       Standard
+    string: type of splice junction output
+                                Standard    ... standard SJ.out.tab output
+                                None        ... no splice junction output
+
+### Output Filtering: Splice Junctions
+outSJfilterReads                All
+    string: which reads to consider for collapsed splice junctions output
+                                All     ... all reads, unique- and multi-mappers
+                                Unique  ... uniquely mapping reads only
+
+outSJfilterOverhangMin          30  12  12  12
+    4 integers:    minimum overhang length for splice junctions on both sides for: (1) non-canonical motifs, (2) GT/AG and CT/AC motif, (3) GC/AG and CT/GC motif, (4) AT/AC and GT/AT motif. -1 means no output for that motif
+                                does not apply to annotated junctions
+
+outSJfilterCountUniqueMin       3   1   1   1
+    4 integers: minimum uniquely mapping read count per junction for: (1) non-canonical motifs, (2) GT/AG and CT/AC motif, (3) GC/AG and CT/GC motif, (4) AT/AC and GT/AT motif. -1 means no output for that motif
+                                Junctions are output if one of outSJfilterCountUniqueMin OR outSJfilterCountTotalMin conditions are satisfied
+                                does not apply to annotated junctions
+
+outSJfilterCountTotalMin     3   1   1   1
+    4 integers: minimum total (multi-mapping+unique) read count per junction for: (1) non-canonical motifs, (2) GT/AG and CT/AC motif, (3) GC/AG and CT/GC motif, (4) AT/AC and GT/AT motif. -1 means no output for that motif
+                                Junctions are output if one of outSJfilterCountUniqueMin OR outSJfilterCountTotalMin conditions are satisfied
+                                does not apply to annotated junctions
+
+outSJfilterDistToOtherSJmin     10  0   5   10
+    4 integers>=0: minimum allowed distance to other junctions' donor/acceptor
+                                does not apply to annotated junctions
+
+outSJfilterIntronMaxVsReadN        50000 100000 200000
+    N integers>=0: maximum gap allowed for junctions supported by 1,2,3,,,N reads
+                                i.e. by default junctions supported by 1 read can have gaps <=50000b, by 2 reads: <=100000b, by 3 reads: <=200000. by >=4 reads any gap <=alignIntronMax
+                                does not apply to annotated junctions
+
+### Scoring
+scoreGap                     0
+    int: splice junction penalty (independent on intron motif)
+
+scoreGapNoncan               -8
+    int: non-canonical junction penalty (in addition to scoreGap)
+
+scoreGapGCAG                 -4
+    int: GC/AG and CT/GC junction penalty (in addition to scoreGap)
+
+scoreGapATAC                 -8
+    int: AT/AC  and GT/AT junction penalty  (in addition to scoreGap)
+
+scoreGenomicLengthLog2scale   -0.25
+    int: extra score logarithmically scaled with genomic length of the alignment: scoreGenomicLengthLog2scale*log2(genomicLength)
+
+scoreDelOpen                 -2
+    int: deletion open penalty
+
+scoreDelBase                 -2
+    int: deletion extension penalty per base (in addition to scoreDelOpen)
+
+scoreInsOpen                 -2
+    int: insertion open penalty
+
+scoreInsBase                 -2
+    int: insertion extension penalty per base (in addition to scoreInsOpen)
+
+scoreStitchSJshift           1
+    int: maximum score reduction while searching for SJ boundaries in the stitching step
+
+
+### Alignments and Seeding
+
+seedSearchStartLmax             50
+    int>0: defines the search start point through the read - the read is split into pieces no longer than this value
+
+seedSearchStartLmaxOverLread    1.0
+    real: seedSearchStartLmax normalized to read length (sum of mates' lengths for paired-end reads)
+
+seedSearchLmax       0
+    int>=0: defines the maximum length of the seeds, if =0 seed length is not limited
+
+seedMultimapNmax      10000
+    int>0: only pieces that map fewer than this value are utilized in the stitching procedure
+
+seedPerReadNmax       1000
+    int>0: max number of seeds per read
+
+seedPerWindowNmax     50
+    int>0: max number of seeds per window
+
+seedNoneLociPerWindow    10
+    int>0: max number of one seed loci per window
+
+seedSplitMin                12
+    int>0: min length of the seed sequences split by Ns or mate gap
+
+seedMapMin              5
+    int>0: min length of seeds to be mapped
+
+alignIntronMin              21
+    int: minimum intron size, genomic gap is considered intron if its length>=alignIntronMin, otherwise it is considered Deletion
+
+alignIntronMax              0
+    int: maximum intron size, if 0, max intron size will be determined by (2^winBinNbits)*winAnchorDistNbins
+
+alignMatesGapMax            0
+    int: maximum gap between two mates, if 0, max intron gap will be determined by (2^winBinNbits)*winAnchorDistNbins
+
+alignSJoverhangMin          5
+    int>0: minimum overhang (i.e. block size) for spliced alignments
+
+alignSJstitchMismatchNmax   0 -1 0 0
+    4*int>=0: maximum number of mismatches for stitching of the splice junctions (-1: no limit).
+                            (1) non-canonical motifs, (2) GT/AG and CT/AC motif, (3) GC/AG and CT/GC motif, (4) AT/AC and GT/AT motif.
+
+alignSJDBoverhangMin        3
+    int>0: minimum overhang (i.e. block size) for annotated (sjdb) spliced alignments
+
+alignSplicedMateMapLmin     0
+    int>0: minimum mapped length for a read mate that is spliced
+
+alignSplicedMateMapLminOverLmate 0.66
+    real>0: alignSplicedMateMapLmin normalized to mate length
+
+alignWindowsPerReadNmax     10000
+    int>0: max number of windows per read
+
+alignTranscriptsPerWindowNmax       100
+    int>0: max number of transcripts per window
+
+alignTranscriptsPerReadNmax               10000
+    int>0: max number of different alignments per read to consider
+
+alignEndsType           Local
+    string: type of read ends alignment
+                        Local             ... standard local alignment with soft-clipping allowed
+                        EndToEnd          ... force end-to-end read alignment, do not soft-clip
+                        Extend5pOfRead1   ... fully extend only the 5p of the read1, all other ends: local alignment
+                        Extend5pOfReads12 ... fully extend only the 5p of the both read1 and read2, all other ends: local alignment
+
+alignEndsProtrude       0    ConcordantPair
+    int, string:        allow protrusion of alignment ends, i.e. start (end) of the +strand mate downstream of the start (end) of the -strand mate
+                        1st word: int: maximum number of protrusion bases allowed
+                        2nd word: string:
+                                            ConcordantPair ... report alignments with non-zero protrusion as concordant pairs
+                                            DiscordantPair ... report alignments with non-zero protrusion as discordant pairs
+
+alignSoftClipAtReferenceEnds    Yes
+    string: allow the soft-clipping of the alignments past the end of the chromosomes
+                                Yes ... allow
+                                No  ... prohibit, useful for compatibility with Cufflinks
+
+alignInsertionFlush     None
+    string: how to flush ambiguous insertion positions
+                        None    ... insertions are not flushed
+                        Right   ... insertions are flushed to the right
+
+### Paired-End reads
+peOverlapNbasesMin          0
+    int>=0:             minimum number of overlapping bases to trigger mates merging and realignment. Specify >0 value to switch on the "merginf of overlapping mates" algorithm.
+
+peOverlapMMp                0.01
+    real, >=0 & <1:     maximum proportion of mismatched bases in the overlap area
+
+### Windows, Anchors, Binning
+
+winAnchorMultimapNmax           50
+    int>0: max number of loci anchors are allowed to map to
+
+winBinNbits                     16
+    int>0: =log2(winBin), where winBin is the size of the bin for the windows/clustering, each window will occupy an integer number of bins.
+
+winAnchorDistNbins              9
+    int>0: max number of bins between two anchors that allows aggregation of anchors into one window
+
+winFlankNbins                   4
+    int>0: log2(winFlank), where win Flank is the size of the left and right flanking regions for each window
+
+winReadCoverageRelativeMin      0.5
+    real>=0: minimum relative coverage of the read sequence by the seeds in a window, for STARlong algorithm only.
+
+winReadCoverageBasesMin      0
+    int>0: minimum number of bases covered by the seeds in a window , for STARlong algorithm only.
+
+### Chimeric Alignments
+chimOutType                 Junctions
+    string(s): type of chimeric output
+                            Junctions       ... Chimeric.out.junction
+                            SeparateSAMold  ... output old SAM into separate Chimeric.out.sam file
+                            WithinBAM       ... output into main aligned BAM files (Aligned.*.bam)
+                            WithinBAM HardClip  ... (default) hard-clipping in the CIGAR for supplemental chimeric alignments (default if no 2nd word is present)
+                            WithinBAM SoftClip  ... soft-clipping in the CIGAR for supplemental chimeric alignments
+
+chimSegmentMin              0
+    int>=0: minimum length of chimeric segment length, if ==0, no chimeric output
+
+chimScoreMin                0
+    int>=0: minimum total (summed) score of the chimeric segments
+
+chimScoreDropMax            20
+    int>=0: max drop (difference) of chimeric score (the sum of scores of all chimeric segments) from the read length
+
+chimScoreSeparation         10
+    int>=0: minimum difference (separation) between the best chimeric score and the next one
+
+chimScoreJunctionNonGTAG    -1
+    int: penalty for a non-GT/AG chimeric junction
+
+chimJunctionOverhangMin     20
+    int>=0: minimum overhang for a chimeric junction
+
+chimSegmentReadGapMax       0
+    int>=0: maximum gap in the read sequence between chimeric segments
+
+chimFilter                  banGenomicN
+    string(s): different filters for chimeric alignments
+                            None ... no filtering
+                            banGenomicN ... Ns are not allowed in the genome sequence around the chimeric junction
+
+chimMainSegmentMultNmax        10
+    int>=1: maximum number of multi-alignments for the main chimeric segment. =1 will prohibit multimapping main segments.
+
+chimMultimapNmax                    0
+    int>=0: maximum number of chimeric multi-alignments
+                                0 ... use the old scheme for chimeric detection which only considered unique alignments
+
+chimMultimapScoreRange          1
+    int>=0: the score range for multi-mapping chimeras below the best chimeric score. Only works with --chimMultimapNmax > 1
+
+chimNonchimScoreDropMin         20
+    int>=0: to trigger chimeric detection, the drop in the best non-chimeric alignment score with respect to the read length has to be greater than this value
+
+chimOutJunctionFormat           0
+    int: formatting type for the Chimeric.out.junction file
+                                0 ... no comment lines/headers
+                                1 ... comment lines at the end of the file: command line and Nreads: total, unique/multi-mapping
+
+### Quantification of Annotations
+quantMode                   -
+    string(s): types of quantification requested
+                            -                ... none
+                            TranscriptomeSAM ... output SAM/BAM alignments to transcriptome into a separate file
+                            GeneCounts       ... count reads per gene
+
+quantTranscriptomeBAMcompression    1
+    int: -2 to 10  transcriptome BAM compression level
+                            -2  ... no BAM output
+                            -1  ... default compression (6?)
+                             0  ... no compression
+                             10 ... maximum compression
+
+quantTranscriptomeSAMoutput BanSingleEnd_BanIndels_ExtendSoftclip
+    string: alignment filtering for TranscriptomeSAM output
+                            BanSingleEnd_BanIndels_ExtendSoftclip ... prohibit indels and single-end alignments, extend softclips - compatible with RSEM
+                            BanSingleEnd               ... prohibit single-end alignments, allow indels and softclips
+                            BanSingleEnd_ExtendSoftclip ... prohibit single-end alignments, extend softclips, allow indels
+
+
+### 2-pass Mapping
+twopassMode                 None
+    string: 2-pass mapping mode.
+                            None        ... 1-pass mapping
+                            Basic       ... basic 2-pass mapping, with all 1st pass junctions inserted into the genome indices on the fly
+
+twopass1readsN              -1
+    int: number of reads to process for the 1st step. Use very large number (or default -1) to map all reads in the first step.
+
+
+### WASP parameters
+waspOutputMode              None
+    string: WASP allele-specific output type. This is re-implementation of the original WASP mappability filtering by Bryce van de Geijn, Graham McVicker, Yoav Gilad & Jonathan K Pritchard. Please cite the original WASP paper: Nature Methods 12, 1061–1063 (2015), https://www.nature.com/articles/nmeth.3582 .
+                            SAMtag      ... add WASP tags to the alignments that pass WASP filtering
+
+### STARsolo (single cell RNA-seq) parameters
+soloType                    None
+    string(s): type of single-cell RNA-seq
+                            CB_UMI_Simple   ... (a.k.a. Droplet) one UMI and one Cell Barcode of fixed length in read2, e.g. Drop-seq and 10X Chromium.
+                            CB_UMI_Complex  ... multiple Cell Barcodes of varying length, one UMI of fixed length and one adapter sequence of fixed length are allowed in read2 only (e.g. inDrop, ddSeq).
+                            CB_samTagOut    ... output Cell Barcode as CR and/or CB SAm tag. No UMI counting. --readFilesIn cDNA_read1 [cDNA_read2 if paired-end] CellBarcode_read . Requires --outSAMtype BAM Unsorted [and/or SortedByCoordinate]
+                            SmartSeq        ... Smart-seq: each cell in a separate FASTQ (paired- or single-end), barcodes are corresponding read-groups, no UMI sequences, alignments deduplicated according to alignment start and end (after extending soft-clipped bases)
+
+soloCBtype                  Sequence
+    string: cell barcode type
+                            Sequence: cell barcode is a sequence (standard option)
+                            String: cell barcode is an arbitrary string
+
+soloCBwhitelist             -
+    string(s): file(s) with whitelist(s) of cell barcodes. Only --soloType CB_UMI_Complex allows more than one whitelist file.
+                            None            ... no whitelist: all cell barcodes are allowed
+
+soloCBstart                 1
+    int>0: cell barcode start base
+
+soloCBlen                   16
+    int>0: cell barcode length
+
+soloUMIstart                17
+    int>0: UMI start base
+
+soloUMIlen                  10
+    int>0: UMI length
+
+soloBarcodeReadLength       1
+    int: length of the barcode read
+                            1   ... equal to sum of soloCBlen+soloUMIlen
+                            0   ... not defined, do not check
+
+soloBarcodeMate             0
+    int: identifies which read mate contains the barcode (CB+UMI) sequence
+                            0   ... barcode sequence is on separate read, which should always be the last file in the --readFilesIn listed
+                            1   ... barcode sequence is a part of mate 1
+                            2   ... barcode sequence is a part of mate 2
+
+soloCBposition              -
+    strings(s):             position of Cell Barcode(s) on the barcode read.
+                            Presently only works with --soloType CB_UMI_Complex, and barcodes are assumed to be on Read2.
+                            Format for each barcode: startAnchor_startPosition_endAnchor_endPosition
+                            start(end)Anchor defines the Anchor Base for the CB: 0: read start; 1: read end; 2: adapter start; 3: adapter end
+                            start(end)Position is the 0-based position with of the CB start(end) with respect to the Anchor Base
+                            String for different barcodes are separated by space.
+                            Example: inDrop (Zilionis et al, Nat. Protocols, 2017):
+                            --soloCBposition  0_0_2_-1  3_1_3_8
+
+soloUMIposition             -
+    string:                  position of the UMI on the barcode read, same as soloCBposition
+                            Example: inDrop (Zilionis et al, Nat. Protocols, 2017):
+                            --soloCBposition  3_9_3_14
+
+soloAdapterSequence         -
+    string:                 adapter sequence to anchor barcodes. Only one adapter sequence is allowed.
+
+soloAdapterMismatchesNmax   1
+    int>0:                  maximum number of mismatches allowed in adapter sequence.
+
+soloCBmatchWLtype           1MM_multi
+    string:                 matching the Cell Barcodes to the WhiteList
+                            Exact                           ... only exact matches allowed
+                            1MM                             ... only one match in whitelist with 1 mismatched base allowed. Allowed CBs have to have at least one read with exact match.
+                            1MM_multi                       ... multiple matches in whitelist with 1 mismatched base allowed, posterior probability calculation is used choose one of the matches.
+                                                                Allowed CBs have to have at least one read with exact match. This option matches best with CellRanger 2.2.0
+                            1MM_multi_pseudocounts          ... same as 1MM_Multi, but pseudocounts of 1 are added to all whitelist barcodes.
+                            1MM_multi_Nbase_pseudocounts    ... same as 1MM_multi_pseudocounts, multimatching to WL is allowed for CBs with N-bases. This option matches best with CellRanger >= 3.0.0
+                            EditDist_2                    ... allow up to edit distance of 3 fpr each of the barcodes. May include one deletion + one insertion. Only works with --soloType CB_UMI_Complex. Matches to multiple passlist barcdoes are not allowed. Similar to ParseBio Split-seq pipeline. 
+
+soloInputSAMattrBarcodeSeq  -
+    string(s):              when inputting reads from a SAM file (--readsFileType SAM SE/PE), these SAM attributes mark the barcode sequence (in proper order).
+                            For instance, for 10X CellRanger or STARsolo BAMs, use --soloInputSAMattrBarcodeSeq CR UR .
+                            This parameter is required when running STARsolo with input from SAM. 
+    
+soloInputSAMattrBarcodeQual  -
+    string(s):              when inputting reads from a SAM file (--readsFileType SAM SE/PE), these SAM attributes mark the barcode qualities (in proper order).
+                            For instance, for 10X CellRanger or STARsolo BAMs, use --soloInputSAMattrBarcodeQual CY UY .
+                            If this parameter is '-' (default), the quality 'H' will be assigned to all bases.
+
+soloStrand                  Forward
+    string: strandedness of the solo libraries:
+                            Unstranded  ... no strand information
+                            Forward     ... read strand same as the original RNA molecule
+                            Reverse     ... read strand opposite to the original RNA molecule
+
+soloFeatures                Gene
+    string(s): genomic features for which the UMI counts per Cell Barcode are collected
+                            Gene            ... genes: reads match the gene transcript
+                            SJ              ... splice junctions: reported in SJ.out.tab
+                            GeneFull        ... full gene (pre-mRNA): count all reads overlapping genes' exons and introns
+                            GeneFull_ExonOverIntron ... full gene (pre-mRNA): count all reads overlapping genes' exons and introns: prioritize 100% overlap with exons
+                            GeneFull_Ex50pAS        ... full gene (pre-RNA): count all reads overlapping genes' exons and introns: prioritize >50% overlap with exons. Do not count reads with 100% exonic overlap in the antisense direction.
+
+#####UnderDevelopment_begin : not supported - do not use
+                            Transcript3p    ... quantification of transcript for 3' protocols
+#####UnderDevelopment_end
+
+soloMultiMappers            Unique
+    string(s): counting method for reads mapping to multiple genes           
+                            Unique     ... count only reads that map to unique genes
+                            Uniform    ... uniformly distribute multi-genic UMIs to all genes
+                            Rescue     ... distribute UMIs proportionally to unique+uniform counts (~ first iteration of EM)
+                            PropUnique ... distribute UMIs proportionally to unique mappers, if present, and uniformly if not.
+                            EM         ... multi-gene UMIs are distributed using Expectation Maximization algorithm
+
+soloUMIdedup                1MM_All
+    string(s):              type of UMI deduplication (collapsing) algorithm
+                            1MM_All                     ... all UMIs with 1 mismatch distance to each other are collapsed (i.e. counted once).
+                            1MM_Directional_UMItools    ... follows the "directional" method from the UMI-tools by Smith, Heger and Sudbery (Genome Research 2017).
+                            1MM_Directional             ... same as 1MM_Directional_UMItools, but with more stringent criteria for duplicate UMIs
+                            Exact                       ... only exactly matching UMIs are collapsed.
+                            NoDedup                     ... no deduplication of UMIs, count all reads.
+                            1MM_CR                      ... CellRanger2-4 algorithm for 1MM UMI collapsing.
+
+soloUMIfiltering            -
+    string(s):              type of UMI filtering (for reads uniquely mapping to genes)
+                            -                  ... basic filtering: remove UMIs with N and homopolymers (similar to CellRanger 2.2.0).
+                            MultiGeneUMI       ... basic + remove lower-count UMIs that map to more than one gene.
+                            MultiGeneUMI_All   ... basic + remove all UMIs that map to more than one gene.
+                            MultiGeneUMI_CR    ... basic + remove lower-count UMIs that map to more than one gene, matching CellRanger > 3.0.0 .
+                                                   Only works with --soloUMIdedup 1MM_CR
+                                                
+soloOutFileNames            Solo.out/          features.tsv barcodes.tsv        matrix.mtx
+    string(s):              file names for STARsolo output:
+                            file_name_prefix   gene_names   barcode_sequences   cell_feature_count_matrix
+
+soloCellFilter              CellRanger2.2 3000 0.99 10
+    string(s):              cell filtering type and parameters
+                            None            ... do not output filtered cells
+                            TopCells        ... only report top cells by UMI count, followed by the exact number of cells
+                            CellRanger2.2   ... simple filtering of CellRanger 2.2. 
+                                                Can be followed by numbers: number of expected cells, robust maximum percentile for UMI count, maximum to minimum ratio for UMI count
+                                                The harcoded values are from CellRanger: nExpectedCells=3000;  maxPercentile=0.99;  maxMinRatio=10
+                            EmptyDrops_CR   ... EmptyDrops filtering in CellRanger flavor. Please cite the original EmptyDrops paper: A.T.L Lun et al, Genome Biology, 20, 63 (2019): https://genomebiology.biomedcentral.com/articles/10.1186/s13059-019-1662-y
+                                                Can be followed by 10 numeric parameters:  nExpectedCells   maxPercentile   maxMinRatio   indMin   indMax   umiMin   umiMinFracMedian   candMaxN   FDR   simN 
+                                                The harcoded values are from CellRanger:             3000            0.99            10    45000    90000      500               0.01      20000  0.01  10000
+
+soloOutFormatFeaturesGeneField3    "Gene Expression"
+    string(s):                field 3 in the Gene features.tsv file. If "-", then no 3rd field is output.
+
+soloCellReadStats           None
+    string:                 Output reads statistics for each CB
+                            Standard    ... standard output
+
+#####UnderDevelopment_begin : not supported - do not use
+soloClusterCBfile           -
+    string:                 file containing the cluster information for cell barcodes, two columns: CB cluster_index. Only used with --soloFeatures Transcript3p
+#####UnderDevelopment_end
diff --git a/tests/tool_audit/help/trimgalore.txt b/tests/tool_audit/help/trimgalore.txt
new file mode 100644
index 00000000..f8e5ac37
--- /dev/null
+++ b/tests/tool_audit/help/trimgalore.txt
@@ -0,0 +1,347 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+ USAGE:
+
+trim_galore [options] <filename(s)>
+
+
+-h/--help               Print this help message and exits.
+
+-v/--version            Print the version information and exits.
+
+-q/--quality <INT>      Trim low-quality ends from reads in addition to adapter removal. For
+                        RRBS samples, quality trimming will be performed first, and adapter
+                        trimming is carried in a second round. Other files are quality and adapter
+                        trimmed in a single pass. The algorithm is the same as the one used by BWA
+                        (Subtract INT from all qualities; compute partial sums from all indices
+                        to the end of the sequence; cut sequence at the index at which the sum is
+                        minimal). Default Phred score: 20.
+
+--phred33               Instructs Cutadapt to use ASCII+33 quality scores as Phred scores
+                        (Sanger/Illumina 1.9+ encoding) for quality trimming. Default: ON.
+
+--phred64               Instructs Cutadapt to use ASCII+64 quality scores as Phred scores
+                        (Illumina 1.5 encoding) for quality trimming.
+
+--fastqc                Run FastQC in the default mode on the FastQ file once trimming is complete.
+
+--fastqc_args "<ARGS>"  Passes extra arguments to FastQC. If more than one argument is to be passed
+                        to FastQC they must be in the form "arg1 arg2 etc.". An example would be:
+                        --fastqc_args "--nogroup --outdir /home/". Passing extra arguments will
+                        automatically invoke FastQC, so --fastqc does not have to be specified
+                        separately.
+
+-a/--adapter <STRING>   Adapter sequence to be trimmed. If not specified explicitly, Trim Galore will
+                        try to auto-detect whether the Illumina universal, Nextera transposase or Illumina
+                        small RNA adapter sequence was used. Also see '--illumina', '--nextera' and
+                        '--small_rna'. If no adapter can be detected within the first 1 million sequences
+                        of the first file specified or if there is a tie between several adapter sequences,
+                        Trim Galore defaults to '--illumina' (as long as the Illumina adapter was one of the
+                        options, else '--nextera' is the default). A single base
+                        may also be given as e.g. -a A{10}, to be expanded to -a AAAAAAAAAA.
+
+-a2/--adapter2 <STRING> Optional adapter sequence to be trimmed off read 2 of paired-end files. This
+                        option requires '--paired' to be specified as well. If the libraries to be trimmed
+                        are smallRNA then a2 will be set to the Illumina small RNA 5' adapter automatically
+                        (GATCGTCGGACT). A single base may also be given as e.g. -a2 A{10}, to be expanded
+                        to -a2 AAAAAAAAAA.
+
+--illumina              Adapter sequence to be trimmed is the first 13bp of the Illumina universal adapter
+                        'AGATCGGAAGAGC' instead of the default auto-detection of adapter sequence.
+
+--nextera               Adapter sequence to be trimmed is the first 12bp of the Nextera adapter
+                        'CTGTCTCTTATA' instead of the default auto-detection of adapter sequence.
+
+--small_rna             Adapter sequence to be trimmed is the first 12bp of the Illumina Small RNA 3' Adapter
+                        'TGGAATTCTCGG' instead of the default auto-detection of adapter sequence. Selecting
+                        to trim smallRNA adapters will also lower the --length value to 18bp. If the smallRNA
+                        libraries are paired-end then a2 will be set to the Illumina small RNA 5' adapter
+                        automatically (GATCGTCGGACT) unless -a 2 had been defined explicitly.
+
+--consider_already_trimmed <INT>     During adapter auto-detection, the limit set by <INT> allows the user to 
+                        set a threshold up to which the file is considered already adapter-trimmed. If no adapter
+                        sequence exceeds this threshold, no additional adapter trimming will be performed (technically,
+                        the adapter is set to '-a X'). Quality trimming is still performed as usual.
+                        Default: NOT SELECTED (i.e. normal auto-detection precedence rules apply).                     
+
+--max_length <INT>      Discard reads that are longer than <INT> bp after trimming. This is only advised for
+                        smallRNA sequencing to remove non-small RNA sequences.
+
+
+--stringency <INT>      Overlap with adapter sequence required to trim a sequence. Defaults to a
+                        very stringent setting of 1, i.e. even a single bp of overlapping sequence
+                        will be trimmed off from the 3' end of any read.
+
+-e <ERROR RATE>         Maximum allowed error rate (no. of errors divided by the length of the matching
+                        region) (default: 0.1)
+
+--gzip                  Compress the output file with GZIP. If the input files are GZIP-compressed
+                        the output files will automatically be GZIP compressed as well. As of v0.2.8 the
+                        compression will take place on the fly.
+
+--dont_gzip             Output files won't be compressed with GZIP. This option overrides --gzip.
+
+--length <INT>          Discard reads that became shorter than length INT because of either
+                        quality or adapter trimming. A value of '0' effectively disables
+                        this behaviour. Default: 20 bp.
+
+                        For paired-end files, both reads of a read-pair need to be longer than
+                        <INT> bp to be printed out to validated paired-end files (see option --paired).
+                        If only one read became too short there is the possibility of keeping such
+                        unpaired single-end reads (see --retain_unpaired). Default pair-cutoff: 20 bp.
+
+--max_n COUNT           The total number of Ns (as integer) a read may contain before it will be removed altogether.
+                        In a paired-end setting, either read exceeding this limit will result in the entire
+                        pair being removed from the trimmed output files.
+
+--trim-n                Removes Ns from either side of the read. This option does currently not work in RRBS mode.
+
+-o/--output_dir <DIR>   If specified all output will be written to this directory instead of the current
+                        directory. If the directory doesn't exist it will be created for you.
+
+--no_report_file        If specified no report file will be generated.
+
+--suppress_warn         If specified any output to STDOUT or STDERR will be suppressed.
+
+--clip_R1 <int>         Instructs Trim Galore to remove <int> bp from the 5' end of read 1 (or single-end
+                        reads). This may be useful if the qualities were very poor, or if there is some
+                        sort of unwanted bias at the 5' end. Default: OFF.
+
+--clip_R2 <int>         Instructs Trim Galore to remove <int> bp from the 5' end of read 2 (paired-end reads
+                        only). This may be useful if the qualities were very poor, or if there is some sort
+                        of unwanted bias at the 5' end. For paired-end BS-Seq, it is recommended to remove
+                        the first few bp because the end-repair reaction may introduce a bias towards low
+                        methylation. Please refer to the M-bias plot section in the Bismark User Guide for
+                        some examples. Default: OFF.
+
+--three_prime_clip_R1 <int>     Instructs Trim Galore to remove <int> bp from the 3' end of read 1 (or single-end
+                        reads) AFTER adapter/quality trimming has been performed. This may remove some unwanted
+                        bias from the 3' end that is not directly related to adapter sequence or basecall quality.
+                        Default: OFF.
+
+--three_prime_clip_R2 <int>     Instructs Trim Galore to remove <int> bp from the 3' end of read 2 AFTER
+                        adapter/quality trimming has been performed. This may remove some unwanted bias from
+                        the 3' end that is not directly related to adapter sequence or basecall quality.
+                        Default: OFF.
+
+--2colour/--nextseq INT This enables the option '--nextseq-trim=3'CUTOFF' within Cutadapt, which will set a quality
+                        cutoff (that is normally given with -q instead), but qualities of G bases are ignored.
+                        This trimming is in common for the NextSeq- and NovaSeq-platforms, where basecalls without
+                        any signal are called as high-quality G bases. This is mutually exlusive with '-q INT'.
+
+
+--path_to_cutadapt </path/to/cutadapt>     You may use this option to specify a path to the Cutadapt executable,
+                        e.g. /my/home/cutadapt-1.7.1/bin/cutadapt. Else it is assumed that Cutadapt is in
+                        the PATH.
+
+--basename <PREFERRED_NAME>	Use PREFERRED_NAME as the basename for output files, instead of deriving the filenames from
+                        the input files. Single-end data would be called PREFERRED_NAME_trimmed.fq(.gz), or
+                        PREFERRED_NAME_val_1.fq(.gz) and PREFERRED_NAME_val_2.fq(.gz) for paired-end data. --basename
+                        only works when 1 file (single-end) or 2 files (paired-end) are specified, but not for longer lists.
+
+-j/--cores INT          Number of cores to be used for trimming [default: 1]. For Cutadapt to work with multiple cores, it
+                        requires Python 3 as well as parallel gzip (pigz) installed on the system. The version of Python used 
+                        is detected from the shebang line of the Cutadapt executable (either 'cutadapt', or a specified path).
+                        If Python 2 is detected, --cores is set to 1.
+                        If pigz cannot be detected on your system, Trim Galore reverts to using gzip compression. Please note
+                        that gzip compression will slow down multi-core processes so much that it is hardly worthwhile, please 
+                        see: https://github.com/FelixKrueger/TrimGalore/issues/16#issuecomment-458557103 for more info).
+						
+                        Actual core usage: It should be mentioned that the actual number of cores used is a little convoluted.
+                        Assuming that Python 3 is used and pigz is installed, --cores 2 would use 2 cores to read the input
+                        (probably not at a high usage though), 2 cores to write to the output (at moderately high usage), and 
+                        2 cores for Cutadapt itself + 2 additional cores for Cutadapt (not sure what they are used for) + 1 core
+                        for Trim Galore itself. So this can be up to 9 cores, even though most of them won't be used at 100% for
+                        most of the time. Paired-end processing uses twice as many cores for the validation (= writing out) step.
+                        --cores 4 would then be: 4 (read) + 4 (write) + 4 (Cutadapt) + 2 (extra Cutadapt) +	1 (Trim Galore) = 15.
+
+                        It seems that --cores 4 could be a sweet spot, anything above has diminishing returns.
+			
+
+
+SPECIFIC TRIMMING - without adapter/quality trimming
+
+--hardtrim5 <int>       Instead of performing adapter-/quality trimming, this option will simply hard-trim sequences
+                        to <int> bp at the 5'-end. Once hard-trimming of files is complete, Trim Galore will exit.
+                        Hard-trimmed output files will end in .<int>_5prime.fq(.gz). Here is an example:
+
+                        before:         CCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAAT
+                        --hardtrim5 20: CCTAAGGAAACAAGTACACT
+
+--hardtrim3 <int>       Instead of performing adapter-/quality trimming, this option will simply hard-trim sequences
+                        to <int> bp at the 3'-end. Once hard-trimming of files is complete, Trim Galore will exit.
+                        Hard-trimmed output files will end in .<int>_3prime.fq(.gz). Here is an example:
+
+                        before:         CCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAAT
+                        --hardtrim3 20:                                                   TTTTTAAGAAAATGGAAAAT
+
+--clock                 In this mode, reads are trimmed in a specific way that is currently used for the Mouse
+                        Epigenetic Clock (see here: Multi-tissue DNA methylation age predictor in mouse, Stubbs et al.,
+                        Genome Biology, 2017 18:68 https://doi.org/10.1186/s13059-017-1203-5). Following this, Trim Galore
+                        will exit.
+
+                        In it's current implementation, the dual-UMI RRBS reads come in the following format:
+
+                        Read 1  5' UUUUUUUU CAGTA FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF TACTG UUUUUUUU 3'
+                        Read 2  3' UUUUUUUU GTCAT FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ATGAC UUUUUUUU 5'
+
+                        Where UUUUUUUU is a random 8-mer unique molecular identifier (UMI), CAGTA is a constant region,
+                        and FFFFFFF... is the actual RRBS-Fragment to be sequenced. The UMIs for Read 1 (R1) and
+                        Read 2 (R2), as well as the fixed sequences (F1 or F2), are written into the read ID and
+                        removed from the actual sequence. Here is an example:
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT
+                            CAATTTTGCAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT:R1:ATCTAGTT:R2:CAATTTTG:F1:CAGT:F2:CAGT
+                                         CGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT:R1:ATCTAGTT:R2:CAATTTTG:F1:CAGT:F2:CAGT
+                                         CAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+                        Following clock trimming, the resulting files (.clock_UMI.R1.fq(.gz) and .clock_UMI.R2.fq(.gz))
+                        should be adapter- and quality trimmed with Trim Galore as usual. In addition, reads need to be trimmed
+                        by 15bp from their 3' end to get rid of potential UMI and fixed sequences. The command is:
+
+                        trim_galore --paired --three_prime_clip_R1 15 --three_prime_clip_R2 15 *.clock_UMI.R1.fq.gz *.clock_UMI.R2.fq.gz
+
+                        Following this, reads should be aligned with Bismark and deduplicated with UmiBam
+                        in '--dual_index' mode (see here: https://github.com/FelixKrueger/Umi-Grinder). UmiBam recognises
+                        the UMIs within this pattern: R1:(ATCTAGTT):R2:(CAATTTTG): as (UMI R1) and (UMI R2).
+
+--polyA                 This is a new, still experimental, trimming mode to identify and remove poly-A tails from sequences.
+                        When --polyA is selected, Trim Galore attempts to identify from the first supplied sample whether
+                        sequences contain more often a stretch of either 'AAAAAAAAAA' or 'TTTTTTTTTT'. This determines
+                        if Read 1 of a paired-end end file, or single-end files, are trimmed for PolyA or PolyT. In case of
+                        paired-end sequencing, Read2 is trimmed for the complementary base from the start of the reads. The
+                        auto-detection uses a default of A{20} for Read1 (3'-end trimming) and T{150} for Read2 (5'-end trimming).
+                        These values may be changed manually using the options -a and -a2.
+
+                        In addition to trimming the sequences, white spaces are replaced with _ and it records in the read ID
+                        how many bases were trimmed so it can later be used to identify PolyA trimmed sequences. This is currently done
+                        by writing tags to both the start ("32:A:") and end ("_PolyA:32") of the reads in the following example:
+
+                        @READ-ID:1:1102:22039:36996 1:N:0:CCTAATCC
+                        GCCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAATAAAAACTTTATAAACACCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+
+                        @32:A:READ-ID:1:1102:22039:36996_1:N:0:CCTAATCC_PolyA:32
+                        GCCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAATAAAAACTTTATAAACACC
+
+                        PLEASE NOTE: The poly-A trimming mode expects that sequences were both adapter and quality trimmed
+                        before looking for Poly-A tails, and it is the user's responsibility to carry out an initial round of
+                        trimming. The following sequence:
+ 
+                        1) trim_galore file.fastq.gz
+                        2) trim_galore --polyA file_trimmed.fq.gz
+                        3) zcat file_trimmed_trimmed.fq.gz | grep -A 3 PolyA | grep -v ^-- > PolyA_trimmed.fastq
+
+                        Will 1) trim qualities and Illumina adapter contamination, 2) find and remove PolyA contamination.
+                        Finally, if desired, 3) will specifically find PolyA trimmed sequences to a specific FastQ file of your choice.
+
+--implicon              This is a special mode of operation for paired-end data, such as required for the IMPLICON method, where a UMI sequence
+                        is getting transferred from the start of Read 2 to the readID of both reads. Following this, Trim Galore will exit.
+
+                        In it's current implementation, the UMI carrying reads come in the following format:
+
+                        Read 1  5' FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 3'
+                        Read 2  3' UUUUUUUUFFFFFFFFFFFFFFFFFFFFFFFFFFFF 5'
+
+                        Where UUUUUUUU is a random 8-mer unique molecular identifier (UMI) and FFFFFFF... is the actual fragment to be
+                        sequenced. The UMI of Read 2 (R2) is written into the read ID of both reads and removed from the actual sequence.
+                        Here is an example:
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT
+                            CAATTTTGCAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+                        
+                        After --implicon trimming:
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT:CAATTTTG
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT:CAATTTTG
+                                    CAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+RRBS-specific options (MspI digested material):
+
+--rrbs                  Specifies that the input file was an MspI digested RRBS sample (recognition
+                        site: CCGG). Single-end or Read 1 sequences (paired-end) which were adapter-trimmed
+                        will have a further 2 bp removed from their 3' end. Sequences which were merely
+                        trimmed because of poor quality will not be shortened further. Read 2 of paired-end
+                        libraries will in addition have the first 2 bp removed from the 5' end (by setting
+                        '--clip_r2 2'). This is to avoid using artificial methylation calls from the filled-in
+                        cytosine positions close to the 3' MspI site in sequenced fragments.
+                        This option is not recommended for users of the NuGEN ovation RRBS System 1-16
+                        kit (see below).
+
+--non_directional       Selecting this option for non-directional RRBS libraries will screen
+                        quality-trimmed sequences for 'CAA' or 'CGA' at the start of the read
+                        and, if found, removes the first two basepairs. Like with the option
+                        '--rrbs' this avoids using cytosine positions that were filled-in
+                        during the end-repair step. '--non_directional' requires '--rrbs' to
+                        be specified as well. Note that this option does not set '--clip_r2 2' in
+                        paired-end mode.
+
+--keep                  Keep the quality trimmed intermediate file. Default: off, which means
+                        the temporary file is being deleted after adapter trimming. Only has
+                        an effect for RRBS samples since other FastQ files are not trimmed
+                        for poor qualities separately.
+
+
+Note for RRBS using the NuGEN Ovation RRBS System 1-16 kit:
+
+Owing to the fact that the NuGEN Ovation kit attaches a varying number of nucleotides (0-3) after each MspI
+site Trim Galore should be run WITHOUT the option --rrbs. This trimming is accomplished in a subsequent
+diversity trimming step afterwards (see their manual).
+
+
+
+Note for RRBS using MseI:
+
+If your DNA material was digested with MseI (recognition motif: TTAA) instead of MspI it is NOT necessary
+to specify --rrbs or --non_directional since virtually all reads should start with the sequence
+'TAA', and this holds true for both directional and non-directional libraries. As the end-repair of 'TAA'
+restricted sites does not involve any cytosines it does not need to be treated especially. Instead, simply
+run Trim Galore! in the standard (i.e. non-RRBS) mode.
+
+
+
+
+Paired-end specific options:
+
+--paired                This option performs length trimming of quality/adapter/RRBS trimmed reads for
+                        paired-end files. To pass the validation test, both sequences of a sequence pair
+                        are required to have a certain minimum length which is governed by the option
+                        --length (see above). If only one read passes this length threshold the
+                        other read can be rescued (see option --retain_unpaired). Using this option lets
+                        you discard too short read pairs without disturbing the sequence-by-sequence order
+                        of FastQ files which is required by many aligners.
+
+                        Trim Galore! expects paired-end files to be supplied in a pairwise fashion, e.g.
+                        file1_1.fq file1_2.fq SRR2_1.fq.gz SRR2_2.fq.gz ... .
+
+-t/--trim1              Trims 1 bp off every read from its 3' end. This may be needed for FastQ files that
+                        are to be aligned as paired-end data with Bowtie. This is because Bowtie (1) regards
+                        alignments like this:
+
+                          R1 --------------------------->     or this:    ----------------------->  R1
+                          R2 <---------------------------                       <-----------------  R2
+
+                        as invalid (whenever a start/end coordinate is contained within the other read).
+                        NOTE: If you are planning to use Bowtie2, BWA etc. you don't need to specify this option.
+
+--retain_unpaired       If only one of the two paired-end reads became too short, the longer
+                        read will be written to either '.unpaired_1.fq' or '.unpaired_2.fq'
+                        output files. The length cutoff for unpaired single-end reads is
+                        governed by the parameters -r1/--length_1 and -r2/--length_2. Default: OFF.
+
+-r1/--length_1 <INT>    Unpaired single-end read length cutoff needed for read 1 to be written to
+                        '.unpaired_1.fq' output file. These reads may be mapped in single-end mode.
+                        Default: 35 bp.
+
+-r2/--length_2 <INT>    Unpaired single-end read length cutoff needed for read 2 to be written to
+                        '.unpaired_2.fq' output file. These reads may be mapped in single-end mode.
+                        Default: 35 bp.
+
+Last modified on 07 October 2020.
+
diff --git a/tests/tool_audit/help/trimgalore_help.txt b/tests/tool_audit/help/trimgalore_help.txt
new file mode 100644
index 00000000..f8e5ac37
--- /dev/null
+++ b/tests/tool_audit/help/trimgalore_help.txt
@@ -0,0 +1,347 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+
+ USAGE:
+
+trim_galore [options] <filename(s)>
+
+
+-h/--help               Print this help message and exits.
+
+-v/--version            Print the version information and exits.
+
+-q/--quality <INT>      Trim low-quality ends from reads in addition to adapter removal. For
+                        RRBS samples, quality trimming will be performed first, and adapter
+                        trimming is carried in a second round. Other files are quality and adapter
+                        trimmed in a single pass. The algorithm is the same as the one used by BWA
+                        (Subtract INT from all qualities; compute partial sums from all indices
+                        to the end of the sequence; cut sequence at the index at which the sum is
+                        minimal). Default Phred score: 20.
+
+--phred33               Instructs Cutadapt to use ASCII+33 quality scores as Phred scores
+                        (Sanger/Illumina 1.9+ encoding) for quality trimming. Default: ON.
+
+--phred64               Instructs Cutadapt to use ASCII+64 quality scores as Phred scores
+                        (Illumina 1.5 encoding) for quality trimming.
+
+--fastqc                Run FastQC in the default mode on the FastQ file once trimming is complete.
+
+--fastqc_args "<ARGS>"  Passes extra arguments to FastQC. If more than one argument is to be passed
+                        to FastQC they must be in the form "arg1 arg2 etc.". An example would be:
+                        --fastqc_args "--nogroup --outdir /home/". Passing extra arguments will
+                        automatically invoke FastQC, so --fastqc does not have to be specified
+                        separately.
+
+-a/--adapter <STRING>   Adapter sequence to be trimmed. If not specified explicitly, Trim Galore will
+                        try to auto-detect whether the Illumina universal, Nextera transposase or Illumina
+                        small RNA adapter sequence was used. Also see '--illumina', '--nextera' and
+                        '--small_rna'. If no adapter can be detected within the first 1 million sequences
+                        of the first file specified or if there is a tie between several adapter sequences,
+                        Trim Galore defaults to '--illumina' (as long as the Illumina adapter was one of the
+                        options, else '--nextera' is the default). A single base
+                        may also be given as e.g. -a A{10}, to be expanded to -a AAAAAAAAAA.
+
+-a2/--adapter2 <STRING> Optional adapter sequence to be trimmed off read 2 of paired-end files. This
+                        option requires '--paired' to be specified as well. If the libraries to be trimmed
+                        are smallRNA then a2 will be set to the Illumina small RNA 5' adapter automatically
+                        (GATCGTCGGACT). A single base may also be given as e.g. -a2 A{10}, to be expanded
+                        to -a2 AAAAAAAAAA.
+
+--illumina              Adapter sequence to be trimmed is the first 13bp of the Illumina universal adapter
+                        'AGATCGGAAGAGC' instead of the default auto-detection of adapter sequence.
+
+--nextera               Adapter sequence to be trimmed is the first 12bp of the Nextera adapter
+                        'CTGTCTCTTATA' instead of the default auto-detection of adapter sequence.
+
+--small_rna             Adapter sequence to be trimmed is the first 12bp of the Illumina Small RNA 3' Adapter
+                        'TGGAATTCTCGG' instead of the default auto-detection of adapter sequence. Selecting
+                        to trim smallRNA adapters will also lower the --length value to 18bp. If the smallRNA
+                        libraries are paired-end then a2 will be set to the Illumina small RNA 5' adapter
+                        automatically (GATCGTCGGACT) unless -a 2 had been defined explicitly.
+
+--consider_already_trimmed <INT>     During adapter auto-detection, the limit set by <INT> allows the user to 
+                        set a threshold up to which the file is considered already adapter-trimmed. If no adapter
+                        sequence exceeds this threshold, no additional adapter trimming will be performed (technically,
+                        the adapter is set to '-a X'). Quality trimming is still performed as usual.
+                        Default: NOT SELECTED (i.e. normal auto-detection precedence rules apply).                     
+
+--max_length <INT>      Discard reads that are longer than <INT> bp after trimming. This is only advised for
+                        smallRNA sequencing to remove non-small RNA sequences.
+
+
+--stringency <INT>      Overlap with adapter sequence required to trim a sequence. Defaults to a
+                        very stringent setting of 1, i.e. even a single bp of overlapping sequence
+                        will be trimmed off from the 3' end of any read.
+
+-e <ERROR RATE>         Maximum allowed error rate (no. of errors divided by the length of the matching
+                        region) (default: 0.1)
+
+--gzip                  Compress the output file with GZIP. If the input files are GZIP-compressed
+                        the output files will automatically be GZIP compressed as well. As of v0.2.8 the
+                        compression will take place on the fly.
+
+--dont_gzip             Output files won't be compressed with GZIP. This option overrides --gzip.
+
+--length <INT>          Discard reads that became shorter than length INT because of either
+                        quality or adapter trimming. A value of '0' effectively disables
+                        this behaviour. Default: 20 bp.
+
+                        For paired-end files, both reads of a read-pair need to be longer than
+                        <INT> bp to be printed out to validated paired-end files (see option --paired).
+                        If only one read became too short there is the possibility of keeping such
+                        unpaired single-end reads (see --retain_unpaired). Default pair-cutoff: 20 bp.
+
+--max_n COUNT           The total number of Ns (as integer) a read may contain before it will be removed altogether.
+                        In a paired-end setting, either read exceeding this limit will result in the entire
+                        pair being removed from the trimmed output files.
+
+--trim-n                Removes Ns from either side of the read. This option does currently not work in RRBS mode.
+
+-o/--output_dir <DIR>   If specified all output will be written to this directory instead of the current
+                        directory. If the directory doesn't exist it will be created for you.
+
+--no_report_file        If specified no report file will be generated.
+
+--suppress_warn         If specified any output to STDOUT or STDERR will be suppressed.
+
+--clip_R1 <int>         Instructs Trim Galore to remove <int> bp from the 5' end of read 1 (or single-end
+                        reads). This may be useful if the qualities were very poor, or if there is some
+                        sort of unwanted bias at the 5' end. Default: OFF.
+
+--clip_R2 <int>         Instructs Trim Galore to remove <int> bp from the 5' end of read 2 (paired-end reads
+                        only). This may be useful if the qualities were very poor, or if there is some sort
+                        of unwanted bias at the 5' end. For paired-end BS-Seq, it is recommended to remove
+                        the first few bp because the end-repair reaction may introduce a bias towards low
+                        methylation. Please refer to the M-bias plot section in the Bismark User Guide for
+                        some examples. Default: OFF.
+
+--three_prime_clip_R1 <int>     Instructs Trim Galore to remove <int> bp from the 3' end of read 1 (or single-end
+                        reads) AFTER adapter/quality trimming has been performed. This may remove some unwanted
+                        bias from the 3' end that is not directly related to adapter sequence or basecall quality.
+                        Default: OFF.
+
+--three_prime_clip_R2 <int>     Instructs Trim Galore to remove <int> bp from the 3' end of read 2 AFTER
+                        adapter/quality trimming has been performed. This may remove some unwanted bias from
+                        the 3' end that is not directly related to adapter sequence or basecall quality.
+                        Default: OFF.
+
+--2colour/--nextseq INT This enables the option '--nextseq-trim=3'CUTOFF' within Cutadapt, which will set a quality
+                        cutoff (that is normally given with -q instead), but qualities of G bases are ignored.
+                        This trimming is in common for the NextSeq- and NovaSeq-platforms, where basecalls without
+                        any signal are called as high-quality G bases. This is mutually exlusive with '-q INT'.
+
+
+--path_to_cutadapt </path/to/cutadapt>     You may use this option to specify a path to the Cutadapt executable,
+                        e.g. /my/home/cutadapt-1.7.1/bin/cutadapt. Else it is assumed that Cutadapt is in
+                        the PATH.
+
+--basename <PREFERRED_NAME>	Use PREFERRED_NAME as the basename for output files, instead of deriving the filenames from
+                        the input files. Single-end data would be called PREFERRED_NAME_trimmed.fq(.gz), or
+                        PREFERRED_NAME_val_1.fq(.gz) and PREFERRED_NAME_val_2.fq(.gz) for paired-end data. --basename
+                        only works when 1 file (single-end) or 2 files (paired-end) are specified, but not for longer lists.
+
+-j/--cores INT          Number of cores to be used for trimming [default: 1]. For Cutadapt to work with multiple cores, it
+                        requires Python 3 as well as parallel gzip (pigz) installed on the system. The version of Python used 
+                        is detected from the shebang line of the Cutadapt executable (either 'cutadapt', or a specified path).
+                        If Python 2 is detected, --cores is set to 1.
+                        If pigz cannot be detected on your system, Trim Galore reverts to using gzip compression. Please note
+                        that gzip compression will slow down multi-core processes so much that it is hardly worthwhile, please 
+                        see: https://github.com/FelixKrueger/TrimGalore/issues/16#issuecomment-458557103 for more info).
+						
+                        Actual core usage: It should be mentioned that the actual number of cores used is a little convoluted.
+                        Assuming that Python 3 is used and pigz is installed, --cores 2 would use 2 cores to read the input
+                        (probably not at a high usage though), 2 cores to write to the output (at moderately high usage), and 
+                        2 cores for Cutadapt itself + 2 additional cores for Cutadapt (not sure what they are used for) + 1 core
+                        for Trim Galore itself. So this can be up to 9 cores, even though most of them won't be used at 100% for
+                        most of the time. Paired-end processing uses twice as many cores for the validation (= writing out) step.
+                        --cores 4 would then be: 4 (read) + 4 (write) + 4 (Cutadapt) + 2 (extra Cutadapt) +	1 (Trim Galore) = 15.
+
+                        It seems that --cores 4 could be a sweet spot, anything above has diminishing returns.
+			
+
+
+SPECIFIC TRIMMING - without adapter/quality trimming
+
+--hardtrim5 <int>       Instead of performing adapter-/quality trimming, this option will simply hard-trim sequences
+                        to <int> bp at the 5'-end. Once hard-trimming of files is complete, Trim Galore will exit.
+                        Hard-trimmed output files will end in .<int>_5prime.fq(.gz). Here is an example:
+
+                        before:         CCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAAT
+                        --hardtrim5 20: CCTAAGGAAACAAGTACACT
+
+--hardtrim3 <int>       Instead of performing adapter-/quality trimming, this option will simply hard-trim sequences
+                        to <int> bp at the 3'-end. Once hard-trimming of files is complete, Trim Galore will exit.
+                        Hard-trimmed output files will end in .<int>_3prime.fq(.gz). Here is an example:
+
+                        before:         CCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAAT
+                        --hardtrim3 20:                                                   TTTTTAAGAAAATGGAAAAT
+
+--clock                 In this mode, reads are trimmed in a specific way that is currently used for the Mouse
+                        Epigenetic Clock (see here: Multi-tissue DNA methylation age predictor in mouse, Stubbs et al.,
+                        Genome Biology, 2017 18:68 https://doi.org/10.1186/s13059-017-1203-5). Following this, Trim Galore
+                        will exit.
+
+                        In it's current implementation, the dual-UMI RRBS reads come in the following format:
+
+                        Read 1  5' UUUUUUUU CAGTA FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF TACTG UUUUUUUU 3'
+                        Read 2  3' UUUUUUUU GTCAT FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ATGAC UUUUUUUU 5'
+
+                        Where UUUUUUUU is a random 8-mer unique molecular identifier (UMI), CAGTA is a constant region,
+                        and FFFFFFF... is the actual RRBS-Fragment to be sequenced. The UMIs for Read 1 (R1) and
+                        Read 2 (R2), as well as the fixed sequences (F1 or F2), are written into the read ID and
+                        removed from the actual sequence. Here is an example:
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT
+                            CAATTTTGCAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT:R1:ATCTAGTT:R2:CAATTTTG:F1:CAGT:F2:CAGT
+                                         CGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT:R1:ATCTAGTT:R2:CAATTTTG:F1:CAGT:F2:CAGT
+                                         CAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+                        Following clock trimming, the resulting files (.clock_UMI.R1.fq(.gz) and .clock_UMI.R2.fq(.gz))
+                        should be adapter- and quality trimmed with Trim Galore as usual. In addition, reads need to be trimmed
+                        by 15bp from their 3' end to get rid of potential UMI and fixed sequences. The command is:
+
+                        trim_galore --paired --three_prime_clip_R1 15 --three_prime_clip_R2 15 *.clock_UMI.R1.fq.gz *.clock_UMI.R2.fq.gz
+
+                        Following this, reads should be aligned with Bismark and deduplicated with UmiBam
+                        in '--dual_index' mode (see here: https://github.com/FelixKrueger/Umi-Grinder). UmiBam recognises
+                        the UMIs within this pattern: R1:(ATCTAGTT):R2:(CAATTTTG): as (UMI R1) and (UMI R2).
+
+--polyA                 This is a new, still experimental, trimming mode to identify and remove poly-A tails from sequences.
+                        When --polyA is selected, Trim Galore attempts to identify from the first supplied sample whether
+                        sequences contain more often a stretch of either 'AAAAAAAAAA' or 'TTTTTTTTTT'. This determines
+                        if Read 1 of a paired-end end file, or single-end files, are trimmed for PolyA or PolyT. In case of
+                        paired-end sequencing, Read2 is trimmed for the complementary base from the start of the reads. The
+                        auto-detection uses a default of A{20} for Read1 (3'-end trimming) and T{150} for Read2 (5'-end trimming).
+                        These values may be changed manually using the options -a and -a2.
+
+                        In addition to trimming the sequences, white spaces are replaced with _ and it records in the read ID
+                        how many bases were trimmed so it can later be used to identify PolyA trimmed sequences. This is currently done
+                        by writing tags to both the start ("32:A:") and end ("_PolyA:32") of the reads in the following example:
+
+                        @READ-ID:1:1102:22039:36996 1:N:0:CCTAATCC
+                        GCCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAATAAAAACTTTATAAACACCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+
+                        @32:A:READ-ID:1:1102:22039:36996_1:N:0:CCTAATCC_PolyA:32
+                        GCCTAAGGAAACAAGTACACTCCACACATGCATAAAGGAAATCAAATGTTATTTTTAAGAAAATGGAAAATAAAAACTTTATAAACACC
+
+                        PLEASE NOTE: The poly-A trimming mode expects that sequences were both adapter and quality trimmed
+                        before looking for Poly-A tails, and it is the user's responsibility to carry out an initial round of
+                        trimming. The following sequence:
+ 
+                        1) trim_galore file.fastq.gz
+                        2) trim_galore --polyA file_trimmed.fq.gz
+                        3) zcat file_trimmed_trimmed.fq.gz | grep -A 3 PolyA | grep -v ^-- > PolyA_trimmed.fastq
+
+                        Will 1) trim qualities and Illumina adapter contamination, 2) find and remove PolyA contamination.
+                        Finally, if desired, 3) will specifically find PolyA trimmed sequences to a specific FastQ file of your choice.
+
+--implicon              This is a special mode of operation for paired-end data, such as required for the IMPLICON method, where a UMI sequence
+                        is getting transferred from the start of Read 2 to the readID of both reads. Following this, Trim Galore will exit.
+
+                        In it's current implementation, the UMI carrying reads come in the following format:
+
+                        Read 1  5' FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 3'
+                        Read 2  3' UUUUUUUUFFFFFFFFFFFFFFFFFFFFFFFFFFFF 5'
+
+                        Where UUUUUUUU is a random 8-mer unique molecular identifier (UMI) and FFFFFFF... is the actual fragment to be
+                        sequenced. The UMI of Read 2 (R2) is written into the read ID of both reads and removed from the actual sequence.
+                        Here is an example:
+
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT
+                            CAATTTTGCAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+                        
+                        After --implicon trimming:
+                        R1: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 1:N:0: CGATGTTT:CAATTTTG
+                            ATCTAGTTCAGTACGGTGTTTTCGAATTAGAAAAATATGTATAGAGGAAATAGATATAAAGGCGTATTCGTTATTG
+                        R2: @HWI-D00436:407:CCAETANXX:1:1101:4105:1905 3:N:0: CGATGTTT:CAATTTTG
+                                    CAGTACAAAAATAATACCTCCTCTATTTATCCAAAATCACAAAAAACCACCCACTTAACTTTCCCTAA
+
+RRBS-specific options (MspI digested material):
+
+--rrbs                  Specifies that the input file was an MspI digested RRBS sample (recognition
+                        site: CCGG). Single-end or Read 1 sequences (paired-end) which were adapter-trimmed
+                        will have a further 2 bp removed from their 3' end. Sequences which were merely
+                        trimmed because of poor quality will not be shortened further. Read 2 of paired-end
+                        libraries will in addition have the first 2 bp removed from the 5' end (by setting
+                        '--clip_r2 2'). This is to avoid using artificial methylation calls from the filled-in
+                        cytosine positions close to the 3' MspI site in sequenced fragments.
+                        This option is not recommended for users of the NuGEN ovation RRBS System 1-16
+                        kit (see below).
+
+--non_directional       Selecting this option for non-directional RRBS libraries will screen
+                        quality-trimmed sequences for 'CAA' or 'CGA' at the start of the read
+                        and, if found, removes the first two basepairs. Like with the option
+                        '--rrbs' this avoids using cytosine positions that were filled-in
+                        during the end-repair step. '--non_directional' requires '--rrbs' to
+                        be specified as well. Note that this option does not set '--clip_r2 2' in
+                        paired-end mode.
+
+--keep                  Keep the quality trimmed intermediate file. Default: off, which means
+                        the temporary file is being deleted after adapter trimming. Only has
+                        an effect for RRBS samples since other FastQ files are not trimmed
+                        for poor qualities separately.
+
+
+Note for RRBS using the NuGEN Ovation RRBS System 1-16 kit:
+
+Owing to the fact that the NuGEN Ovation kit attaches a varying number of nucleotides (0-3) after each MspI
+site Trim Galore should be run WITHOUT the option --rrbs. This trimming is accomplished in a subsequent
+diversity trimming step afterwards (see their manual).
+
+
+
+Note for RRBS using MseI:
+
+If your DNA material was digested with MseI (recognition motif: TTAA) instead of MspI it is NOT necessary
+to specify --rrbs or --non_directional since virtually all reads should start with the sequence
+'TAA', and this holds true for both directional and non-directional libraries. As the end-repair of 'TAA'
+restricted sites does not involve any cytosines it does not need to be treated especially. Instead, simply
+run Trim Galore! in the standard (i.e. non-RRBS) mode.
+
+
+
+
+Paired-end specific options:
+
+--paired                This option performs length trimming of quality/adapter/RRBS trimmed reads for
+                        paired-end files. To pass the validation test, both sequences of a sequence pair
+                        are required to have a certain minimum length which is governed by the option
+                        --length (see above). If only one read passes this length threshold the
+                        other read can be rescued (see option --retain_unpaired). Using this option lets
+                        you discard too short read pairs without disturbing the sequence-by-sequence order
+                        of FastQ files which is required by many aligners.
+
+                        Trim Galore! expects paired-end files to be supplied in a pairwise fashion, e.g.
+                        file1_1.fq file1_2.fq SRR2_1.fq.gz SRR2_2.fq.gz ... .
+
+-t/--trim1              Trims 1 bp off every read from its 3' end. This may be needed for FastQ files that
+                        are to be aligned as paired-end data with Bowtie. This is because Bowtie (1) regards
+                        alignments like this:
+
+                          R1 --------------------------->     or this:    ----------------------->  R1
+                          R2 <---------------------------                       <-----------------  R2
+
+                        as invalid (whenever a start/end coordinate is contained within the other read).
+                        NOTE: If you are planning to use Bowtie2, BWA etc. you don't need to specify this option.
+
+--retain_unpaired       If only one of the two paired-end reads became too short, the longer
+                        read will be written to either '.unpaired_1.fq' or '.unpaired_2.fq'
+                        output files. The length cutoff for unpaired single-end reads is
+                        governed by the parameters -r1/--length_1 and -r2/--length_2. Default: OFF.
+
+-r1/--length_1 <INT>    Unpaired single-end read length cutoff needed for read 1 to be written to
+                        '.unpaired_1.fq' output file. These reads may be mapped in single-end mode.
+                        Default: 35 bp.
+
+-r2/--length_2 <INT>    Unpaired single-end read length cutoff needed for read 2 to be written to
+                        '.unpaired_2.fq' output file. These reads may be mapped in single-end mode.
+                        Default: 35 bp.
+
+Last modified on 07 October 2020.
+
diff --git a/tests/tool_audit/help/umicollapse.txt b/tests/tool_audit/help/umicollapse.txt
new file mode 100644
index 00000000..d614ca63
--- /dev/null
+++ b/tests/tool_audit/help/umicollapse.txt
@@ -0,0 +1,4 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Arguments	[--help]
+Exception in thread "main" java.lang.IllegalArgumentException: Missing input file!
+	at umicollapse.main.Main.main(Main.java:115)
diff --git a/tests/tool_audit/help/umicollapse2.txt b/tests/tool_audit/help/umicollapse2.txt
new file mode 100644
index 00000000..6e4c40e1
--- /dev/null
+++ b/tests/tool_audit/help/umicollapse2.txt
@@ -0,0 +1,4 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Arguments	[-h]
+Exception in thread "main" java.lang.IllegalArgumentException: Missing input file!
+	at umicollapse.main.Main.main(Main.java:115)
diff --git a/tests/tool_audit/help/umicollapse_bam.txt b/tests/tool_audit/help/umicollapse_bam.txt
new file mode 100644
index 00000000..b720296f
--- /dev/null
+++ b/tests/tool_audit/help/umicollapse_bam.txt
@@ -0,0 +1,4 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Arguments	[bam, --help]
+Exception in thread "main" java.lang.IllegalArgumentException: Missing input file!
+	at umicollapse.main.Main.main(Main.java:115)
diff --git a/tests/tool_audit/help/umicollapse_fastq.txt b/tests/tool_audit/help/umicollapse_fastq.txt
new file mode 100644
index 00000000..6fe6752c
--- /dev/null
+++ b/tests/tool_audit/help/umicollapse_fastq.txt
@@ -0,0 +1,4 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+Arguments	[fastq, --help]
+Exception in thread "main" java.lang.IllegalArgumentException: Missing input file!
+	at umicollapse.main.Main.main(Main.java:115)
diff --git a/tests/tool_audit/help/umitools.txt b/tests/tool_audit/help/umitools.txt
new file mode 100644
index 00000000..bd646d82
--- /dev/null
+++ b/tests/tool_audit/help/umitools.txt
@@ -0,0 +1,29 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+For full UMI-tools documentation, see: https://umi-tools.readthedocs.io/en/latest/
+
+
+umi_tools.py - Tools for UMI analyses
+===============================================
+
+:Author: Tom Smith & Ian Sudbury, CGAT
+:Release: $Id$
+:Date: |today|
+:Tags: Genomics UMI
+
+There are 6 tools:
+
+  - whitelist
+  - extract
+  - group
+  - dedup
+  - count
+  - count_tab
+
+To get help on a specific tool, type:
+
+    umi_tools <tool> --help
+
+To use a specific tool, type::
+
+    umi_tools <tool> [tool options] [tool arguments]
+
diff --git a/tests/tool_audit/help/umitools_dedup.txt b/tests/tool_audit/help/umitools_dedup.txt
new file mode 100644
index 00000000..056103f1
--- /dev/null
+++ b/tests/tool_audit/help/umitools_dedup.txt
@@ -0,0 +1,136 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+UMI-Tools: Version 1.1.2
+
+dedup - Deduplicate reads using UMI and mapping coordinates
+
+Usage: umi_tools dedup [OPTIONS] [--stdin=IN_BAM] [--stdout=OUT_BAM]
+
+       note: If --stdout is ommited, standard out is output. To
+             generate a valid BAM file on standard out, please
+             redirect log with --log=LOGFILE or --log2stderr 
+
+For full UMI-tools documentation, see https://umi-tools.readthedocs.io/en/latest/
+
+Options:
+  --version             show program's version number and exit
+
+  dedup-specific options:
+    --output-stats=STATS
+                        Specify location to output stats
+
+  Barcode extraction options:
+    --extract-umi-method=GET_UMI_METHOD
+                        how is the read UMI +/ cell barcode encoded?
+                        [default=read_id]
+    --umi-separator=UMI_SEP
+                        separator between read id and UMI
+    --umi-tag=UMI_TAG   tag containing umi
+    --umi-tag-split=UMI_TAG_SPLIT
+                        split UMI in tag and take the first element
+    --umi-tag-delimiter=UMI_TAG_DELIM
+                        concatenate UMI in tag separated by delimiter
+    --cell-tag=CELL_TAG
+                        tag containing cell barcode
+    --cell-tag-split=CELL_TAG_SPLIT
+                        split cell barcode in tag and take the firstelement
+                        for e.g 10X GEM tags
+    --cell-tag-delimiter=CELL_TAG_DELIM
+                        concatenate cell barcode in tag separated by delimiter
+
+  UMI grouping options:
+    --method=METHOD     method to use for umi grouping [default=directional]
+    --edit-distance-threshold=THRESHOLD
+                        Edit distance theshold at which to join two UMIs when
+                        grouping UMIs. [default=1]
+    --spliced-is-unique
+                        Treat a spliced read as different to an unspliced one
+                        [default=False]
+    --soft-clip-threshold=SOFT_CLIP_THRESHOLD
+                        number of bases clipped from 5' end before read is
+                        counted as spliced [default=4]
+    --read-length       use read length in addition to position and UMI to
+                        identify possible duplicates [default=False]
+
+  single-cell RNA-Seq options:
+    --per-gene          Group/Dedup/Count per gene. Must combine with either
+                        --gene-tag or --per-contig
+    --gene-tag=GENE_TAG
+                        Gene is defined by this bam tag [default=none]
+    --assigned-status-tag=ASSIGNED_TAG
+                        Bam tag describing whether read is assigned to a gene
+                        By defualt, this is set as the same tag as --gene-tag
+    --skip-tags-regex=SKIP_REGEX
+                        Used with --gene-tag. Ignore reads where the gene-tag
+                        matches this regex
+    --per-contig        group/dedup/count UMIs per contig (field 3 in BAM;
+                        RNAME), e.g for transcriptome where contig = gene
+    --gene-transcript-map=GENE_TRANSCRIPT_MAP
+                        File mapping transcripts to genes (tab separated)
+    --per-cell          group/dedup/count per cell
+
+  group/dedup options:
+    --buffer-whole-contig
+                        Read whole contig before outputting bundles:
+                        guarantees that no reads are missed, but increases
+                        memory usage
+    --multimapping-detection-method=DETECTION_METHOD
+                        Some aligners identify multimapping using bam tags.
+                        Setting this option to NH, X0 or XT will use these
+                        tags when selecting the best read amongst reads with
+                        the same position and umi [default=none]
+
+  SAM/BAM options:
+    --mapping-quality=MAPPING_QUALITY
+                        Minimum mapping quality for a read to be retained
+                        [default=0]
+    --unmapped-reads=UNMAPPED_READS
+                        How to handle unmapped reads. Options are 'discard',
+                        'use' or 'correct' [default=discard]
+    --chimeric-pairs=CHIMERIC_PAIRS
+                        How to handle chimeric read pairs. Options are
+                        'discard', 'use' or 'correct' [default=use]
+    --unpaired-reads=UNPAIRED_READS
+                        How to handle unpaired reads. Options are 'discard',
+                        'use' or 'correct' [default=use]
+    --ignore-umi        Ignore UMI and dedup only on position
+    --ignore-tlen       Option to dedup paired end reads based solely on
+                        read1, whether or not the template length is the same
+    --chrom=CHROM       Restrict to one chromosome
+    --subset=SUBSET     Use only a fraction of reads, specified by subset
+    -i, --in-sam        Input file is in sam format [default=False]
+    --paired            paired input BAM. [default=False]
+    -o, --out-sam       Output alignments in sam format [default=False]
+    --no-sort-output    Don't Sort the output
+
+  input/output options:
+    -I FILE, --stdin=FILE
+                        file to read stdin from [default = stdin].
+    -L FILE, --log=FILE
+                        file with logging information [default = stdout].
+    -E FILE, --error=FILE
+                        file with error information [default = stderr].
+    -S FILE, --stdout=FILE
+                        file where output is to go [default = stdout].
+    --temp-dir=FILE     Directory for temporary files. If not set, the bash
+                        environmental variable TMPDIR is used[default = None].
+    --log2stderr        send logging information to stderr [default = False].
+    --compresslevel=COMPRESSLEVEL
+                        Level of Gzip compression to use. Default (6)
+                        matchesGNU gzip rather than python gzip default (which
+                        is 9)
+
+  profiling options:
+    --timeit=TIMEIT_FILE
+                        store timeing information in file [none].
+    --timeit-name=TIMEIT_NAME
+                        name in timing file for this class of jobs [all].
+    --timeit-header     add header for timing information [none].
+
+  common options:
+    -v LOGLEVEL, --verbose=LOGLEVEL
+                        loglevel [1]. The higher, the more output.
+    -h, --help          output short help (command line options only).
+    --help-extended     Output full documentation
+    --random-seed=RANDOM_SEED
+                        random seed to initialize number generator with
+                        [none].
diff --git a/tests/tool_audit/help/umitools_extract.txt b/tests/tool_audit/help/umitools_extract.txt
new file mode 100644
index 00000000..e2ed7c82
--- /dev/null
+++ b/tests/tool_audit/help/umitools_extract.txt
@@ -0,0 +1,111 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+UMI-Tools: Version 1.1.2
+
+extract - Extract UMI from fastq
+
+Usage:
+
+   Single-end:
+      umi_tools extract [OPTIONS] -p PATTERN [-I IN_FASTQ[.gz]] [-S OUT_FASTQ[.gz]]
+
+   Paired end:
+      umi_tools extract [OPTIONS] -p PATTERN [-I IN_FASTQ[.gz]] [-S OUT_FASTQ[.gz]] --read2-in=IN2_FASTQ[.gz] --read2-out=OUT2_FASTQ[.gz]
+
+   note: If -I/-S are ommited standard in and standard out are used
+         for input and output.  To generate a valid BAM file on
+         standard out, please redirect log with --log=LOGFILE or
+         --log2stderr. Input/Output will be (de)compressed if a
+         filename provided to -S/-I/--read2-in/read2-out ends in .gz
+         
+
+For full UMI-tools documentation, see https://umi-tools.readthedocs.io/en/latest/
+
+Options:
+  --version             show program's version number and exit
+
+  extract-specific options:
+    --read2-out=READ2_OUT
+                        file to output processed paired read to
+    --read2-stdout      Paired reads, send read2 to stdout, discarding read1
+    --quality-filter-threshold=QUALITY_FILTER_THRESHOLD
+                        Remove reads where any UMI base quality score falls
+                        below this threshold
+    --quality-filter-mask=QUALITY_FILTER_MASK
+                        If a UMI base has a quality below this threshold,
+                        replace the base with 'N'
+    --quality-encoding=QUALITY_ENCODING
+                        Quality score encoding. Choose from 'phred33'[33-77]
+                        'phred64' [64-106] or 'solexa' [59-106]
+    --error-correct-cell
+                        Correct errors in the cell barcode
+    --whitelist=WHITELIST
+                        A whitelist of accepted cell barcodes
+    --blacklist=BLACKLIST
+                        A blacklist of rejected cell barcodes
+    --subset-reads=READS_SUBSET, --reads-subset=READS_SUBSET
+                        Only extract from the first N reads. If N is greater
+                        than the number of reads, all reads will be used
+    --reconcile-pairs   Allow the presences of reads in read2 input that are
+                        not present in read1 input. This allows cell barcode
+                        filtering of read1s without considering read2s
+
+  [EXPERIMENTAl] barcode extraction options:
+    --either-read       UMI may be on either read (see --either-read-resolve)
+                        for options to resolve cases whereUMI is on both reads
+    --either-read-resolve=EITHER_READ_RESOLVE
+                        How to resolve instances where both reads contain a
+                        UMI but using --either-read.Choose from 'discard' or
+                        'quality'(use highest quality). default=dicard
+
+  fastq barcode extraction options:
+    --extract-method=EXTRACT_METHOD
+                        How to extract the umi +/- cell barcodes, Choose from
+                        'string' or 'regex'
+    -p PATTERN, --bc-pattern=PATTERN
+                        Barcode pattern
+    --bc-pattern2=PATTERN2
+                        Barcode pattern for paired reads
+    --3prime            barcode is on 3' end of read.
+    --read2-in=READ2_IN
+                        file name for read pairs
+    --filtered-out=FILTERED_OUT
+                        Write out reads not matching regex pattern to this
+                        file
+    --filtered-out2=FILTERED_OUT2
+                        Write out paired reads not matching regex pattern to
+                        this file
+    --ignore-read-pair-suffixes
+                        Ignore '\1' and '\2' read name suffixes
+
+  input/output options:
+    -I FILE, --stdin=FILE
+                        file to read stdin from [default = stdin].
+    -L FILE, --log=FILE
+                        file with logging information [default = stdout].
+    -E FILE, --error=FILE
+                        file with error information [default = stderr].
+    -S FILE, --stdout=FILE
+                        file where output is to go [default = stdout].
+    --temp-dir=FILE     Directory for temporary files. If not set, the bash
+                        environmental variable TMPDIR is used[default = None].
+    --log2stderr        send logging information to stderr [default = False].
+    --compresslevel=COMPRESSLEVEL
+                        Level of Gzip compression to use. Default (6)
+                        matchesGNU gzip rather than python gzip default (which
+                        is 9)
+
+  profiling options:
+    --timeit=TIMEIT_FILE
+                        store timeing information in file [none].
+    --timeit-name=TIMEIT_NAME
+                        name in timing file for this class of jobs [all].
+    --timeit-header     add header for timing information [none].
+
+  common options:
+    -v LOGLEVEL, --verbose=LOGLEVEL
+                        loglevel [1]. The higher, the more output.
+    -h, --help          output short help (command line options only).
+    --help-extended     Output full documentation
+    --random-seed=RANDOM_SEED
+                        random seed to initialize number generator with
+                        [none].
diff --git a/tests/tool_audit/help/umitools_whitelist.txt b/tests/tool_audit/help/umitools_whitelist.txt
new file mode 100644
index 00000000..f564e210
--- /dev/null
+++ b/tests/tool_audit/help/umitools_whitelist.txt
@@ -0,0 +1,104 @@
+INFO:    gocryptfs not found, will not be able to use gocryptfs
+UMI-Tools: Version 1.1.2
+
+whitelist - Generates a whitelist of accepted cell barcodes
+
+Usage:
+
+   Single-end:
+      umi_tools whitelist [OPTIONS] [-I IN_FASTQ[.gz]] [-S OUT_TSV[.gz]]
+
+   Paired end:
+      umi_tools whitelist [OPTIONS] [-I IN_FASTQ[.gz]] [-S OUT_TSV[.gz]] --read2-in=IN2_FASTQ[.gz]
+
+   note: If -I/-S are ommited standard in and standard out are used
+         for input and output.  Input/Output will be (de)compressed if a
+         filename provided to -S/-I/--read2-in ends in .gz
+
+
+For full UMI-tools documentation, see https://umi-tools.readthedocs.io/en/latest/
+
+Options:
+  --version             show program's version number and exit
+  --ed-above-threshold=ED_ABOVE_THRESHOLD
+                        Detect CBs above the threshold which may be sequence
+                        errors from another CB and either 'discard' or
+                        'correct'. Default=discard
+
+  whitelist-specific options:
+    --plot-prefix=PLOT_PREFIX
+                        Prefix for plots to visualise the automated detection
+                        of the number of 'true' cell barcodes
+    --subset-reads=SUBSET_READS
+                        Use the first N reads to automatically identify the
+                        true cell barcodes. If N is greater than the number of
+                        reads, all reads will be used. Default is 100,000,000
+    --error-correct-threshold=ERROR_CORRECT_THRESHOLD
+                        Hamming distance for correction of barcodes to
+                        whitelist barcodes. This value will also be used for
+                        error detection above the knee if required (--ed-
+                        above-threshold)
+    --method=METHOD     Use reads or unique umi counts per cell
+    --knee-method=KNEE_METHOD
+                        Use distance or density methods for detection of knee
+    --expect-cells=EXPECT_CELLS
+                        Prior expectation on the upper limit on the number of
+                        cells sequenced
+    --allow-threshold-error
+                        Don't select a threshold. Will still output the plots
+                        if requested (--plot-prefix)
+    --set-cell-number=CELL_NUMBER
+                        Specify the number of cell barcodes to accept
+
+  fastq barcode extraction options:
+    --extract-method=EXTRACT_METHOD
+                        How to extract the umi +/- cell barcodes, Choose from
+                        'string' or 'regex'
+    -p PATTERN, --bc-pattern=PATTERN
+                        Barcode pattern
+    --bc-pattern2=PATTERN2
+                        Barcode pattern for paired reads
+    --3prime            barcode is on 3' end of read.
+    --read2-in=READ2_IN
+                        file name for read pairs
+    --filtered-out=FILTERED_OUT
+                        Write out reads not matching regex pattern to this
+                        file
+    --filtered-out2=FILTERED_OUT2
+                        Write out paired reads not matching regex pattern to
+                        this file
+    --ignore-read-pair-suffixes
+                        Ignore '\1' and '\2' read name suffixes
+
+  input/output options:
+    -I FILE, --stdin=FILE
+                        file to read stdin from [default = stdin].
+    -L FILE, --log=FILE
+                        file with logging information [default = stdout].
+    -E FILE, --error=FILE
+                        file with error information [default = stderr].
+    -S FILE, --stdout=FILE
+                        file where output is to go [default = stdout].
+    --temp-dir=FILE     Directory for temporary files. If not set, the bash
+                        environmental variable TMPDIR is used[default = None].
+    --log2stderr        send logging information to stderr [default = False].
+    --compresslevel=COMPRESSLEVEL
+                        Level of Gzip compression to use. Default (6)
+                        matchesGNU gzip rather than python gzip default (which
+                        is 9)
+
+  profiling options:
+    --timeit=TIMEIT_FILE
+                        store timeing information in file [none].
+    --timeit-name=TIMEIT_NAME
+                        name in timing file for this class of jobs [all].
+    --timeit-header     add header for timing information [none].
+
+  common options:
+    -v LOGLEVEL, --verbose=LOGLEVEL
+                        loglevel [1]. The higher, the more output.
+    -h, --help          output short help (command line options only).
+    --help-extended     Output full documentation
+    --random-seed=RANDOM_SEED
+                        random seed to initialize number generator with
+                        [none].
diff --git a/tests/tool_audit/nf_script_commands.txt b/tests/tool_audit/nf_script_commands.txt
new file mode 100644
index 00000000..2ae06988
--- /dev/null
+++ b/tests/tool_audit/nf_script_commands.txt
@@ -0,0 +1,1535 @@
+### alevinfry.nf
+
+    zcat $anno | awk 'BEGIN{FS="\\t";OFS="\\t"} \$3=="transcript"{match(\$9,/transcript_id "[^"]+"/); t=substr(\$9,RSTART+15,RLENGTH-16); match(\$9,/gene_id "[^"]+"/); g=substr(\$9,RSTART+9,RLENGTH-10); print t,g}' > t2g.tsv
+    
+
+### alevinfry.nf
+
+    $COUNTBIN generate-permit-list -i $raddir -d fw $PERMITPARAMS -o $qd &> $lf; $COUNTBIN collate -i $qd -r $raddir -t ${task.cpus} &>> $lf; $COUNTBIN quant -i $qd -m $t2g -t ${task.cpus} -r cr-like $COUNTPARAMS -o $qd --use-mtx &>> $lf
+    
+
+### bbduk.nf
+
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in1=$r1 in2=$r2 out1=$o out2=$p &> $r 
+        
+
+### bbduk.nf
+
+        $TRIMBIN $TRIMPARAMS t=${task.cpus} in=$r1 out=$o &> $r 
+        
+
+### bwa.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### bwa.nf
+
+    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa.idx
+    
+
+### bwa.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### bwa.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### bwa2.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### bwa2.nf
+
+    mkdir -p $MAPUIDXNAME && $IDXBIN index -p $MAPUIDXNAME/$MAPPREFIX $IDXPARAMS $gen &> Log.out && ln -fs $MAPUIDXNAME bwa2.idx
+    
+
+### bwa2.nf
+
+        $MAPBIN mem $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $r1 $r2  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### bwa2.nf
+
+        $MAPBIN mem $MAPPARAMS -t ${task.cpus} ${idx}/${MAPPREFIX} $read  2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### bwameth.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### bwameth.nf
+
+    mkdir -p $MAPUIDXNAME && zcat $gen > $MAPUIDXNAME/$genfa && $IDXBIN $MAPUIDXNAME/$genfa $IDXPARAMS &> Log.out && ln -fs $MAPUIDXNAME/$genfa bwameth.idx
+    
+
+### bwameth.nf
+
+        touch ${idx}/${MAPPREFIX}*c2t*; $MAPBIN $MAPPARAMS --threads ${task.cpus} --reference ${idx}/${MAPPREFIX}*.fa $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### bwameth.nf
+
+        touch ${idx}/${MAPPREFIX}*c2t*; $MAPBIN $MAPPARAMS --threads ${task.cpus} --reference ${idx}/${MAPPREFIX}*.fa $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### ciri2.nf
+
+    set +o pipefail; export LC_ALL=C; if [[ -n \"\$(zcat ${reads} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then mkdir -p TMP && zcat ${reads}|samtools sort -n -@ ${task.cpus} -u -O sam -T TMP > ${fn}_tmp.sam && zcat ${anno} > ${fn}_tmp.gtf && zcat ${ref} > ${fn}_tmp.fa && perl $CIRCBIN -I ${fn}_tmp.sam -O ${fn}_circs -F ${fn}_tmp.fa -T ${task.cpus} -A ${fn}_tmp.gtf -G log $CIRCPARAMS &>> log; else gzip < /dev/null > ${fn}_circs; echo \"File ${reads} empty\" >> log; fi; touch CIRIerror.log && cat CIRIerror.log >> {log} && echo '' > CIRIerror.log && touch ${fn}_circs
+    
+
+### collect.nf
+
+    echo "$check successful!" > collect.txt
+    
+
+### countreads.nf
+
+        a=\$(zcat $r1|wc -l ); echo \$((a/4)) > $oo 2>> $ol &&
+        a=\$(zcat $r2|wc -l ); echo \$((a/4)) > $ot 2>> $ol
+        
+
+### countreads.nf
+
+        a=\$(zcat $reads|wc -l ); echo \$((a/4)) > $oc 2>> $ol
+        
+
+### countreads.nf
+
+        a=\$(zcat $r1|wc -l ); echo \$((a/4)) > $oo 2>> $ol &&
+        a=\$(zcat $r2|wc -l ); echo \$((a/4)) > $ot 2>> $ol
+        
+
+### countreads.nf
+
+        a=\$(zcat $reads|wc -l ); echo \$((a/4)) > $oc 2>> $ol
+        
+
+### countreads.nf
+
+        a=\$(zcat $r1|wc -l ); echo \$((a/4)) > $oo 2>> $ol &&
+        a=\$(zcat $r2|wc -l ); echo \$((a/4)) > $ot 2>> $ol
+        
+
+### countreads.nf
+
+        a=\$(zcat $reads|wc -l ); echo \$((a/4)) > $oc 2>> $ol
+        
+
+### countreads.nf
+
+    mkdir -p TMP; export LC_ALL=C; samtools view -F 260 $reads | cut -d\$'\\t' -f1|sort --parallel=${task.cpus} -S $sortmem -T TMP -u |wc -l > $oc 2>> $ol
+    
+
+### countreads.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded $COUNTMAP -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### countreads.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### countreads.nf
+
+    for i in $reads;do echo -ne \"\$i\\t\" >> summary && if [[ -s \$i ]]; then cat \$i >> summary; else echo '0' >> summary;fi; done 2>> log
+    
+
+### cutadapt.nf
+
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o -p $p $r1 $r2 &> $r
+        
+
+### cutadapt.nf
+
+        $TRIMBIN --cores ${task.cpus} $TRIMPARAMS -o $o $reads &> $r
+        
+
+### deseq2_DE.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### deseq2_DE.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### deseq2_DE.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    
+
+### deseq2_DE.nf
+
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    
+
+### deseq2_DE.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DEENV --loglevel DEBUG 2>> log
+    
+
+### deseq2_DE.nf
+
+    echo "$de DONE"
+    
+
+### dexseq_DEU.nf
+
+    mkdir -p TMP; $BINS/Analysis/DEU/prepare_deu_annotation.py --nextflow -f $ca $stranded $anno $da 2>> $ol
+    
+
+### dexseq_DEU.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $fcanno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### dexseq_DEU.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DEUREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### dexseq_DEU.nf
+
+    mkdir -p Figures Tables DEXSeqReport_${COMBO}_$comp;
+    Rscript --no-environ --no-restore --no-save $bin $anno $cts $refan $deanno . $DEUCOMP $PCOMBO ${task.cpus} $DEUPARAMS 2> log && mv Tables/* . && mv Figures/* . && mv DEXSeqReport_*/* .
+
+    
+
+### dexseq_DEU.nf
+
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    
+
+### dexseq_DEU.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DEUENV --loglevel DEBUG 2>> log
+    
+
+### dexseq_DEU.nf
+
+    echo "$de DONE"
+    
+
+### dexseq_DTU.nf
+
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME dexseq.idx
+    
+
+### dexseq_DTU.nf
+
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    
+
+### dexseq_DTU.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    
+
+### dexseq_DTU.nf
+
+    echo "$de DONE"
+    
+
+### diego_DAS.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### diego_DAS.nf
+
+    echo $DASSAMPLES|sed -e 's/:/\\t/' -e 's/\\|/\\n/' 1> samplemap.txt 2>> log && echo $DASGROUPS|sed -e 's/:/\\t/' -e 's/\\|/\\n/' 1> groupings.txt 2>> log
+    
+
+### diego_DAS.nf
+
+    python ${BINS}/Analysis/DAS/FeatureCounts2DIEGO.py $DASREPS --table junction_table.txt.gz --anno ANNOTATION.gz 2> log
+    
+
+### diego_DAS.nf
+
+    python ${BINS}/Analysis/DAS/diego_contrast_files.py -a <(zcat $anno) -b $DASCOMPS -c $DASCOMP -o . 2> log
+    
+
+### diego_DAS.nf
+    
+    arr=($contrast); for i in \${!arr[@]}; do basecond=\$(head -n 1 \${arr[\$i]} | awk \'{print \$1}\'); outcond=\$(echo \${basecond}|sed \'s/_[0-9]+//g\'); $bin -a <(zcat $tbl) -b \${arr[\$i]} -x \${basecond} -e -f ${outcomb}_\${outcond}_figure_dendrogram &> log; $bin -a <(zcat $tbl) -b \${arr[\$i]} -x \$basecond $DASPARAMS 1> ${outcomb}_\${outcond}_table_results.csv 2>> log;done
+    
+
+### diego_DAS.nf
+
+    set +o pipefail; arr=($tabs); for i in \${!arr[@]}; do a=\${arr[\$i]}; fn=\${a##*/}; if [[ -s \"\$a\" ]];then cat \$a|head -n1 > Sig_\$a; cat \$a| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[10]);if (\$F[10] eq \"yes\") {print}' >> Sig_\$a &>> log; else touch \${orr[\$i]}; fi; done
+    
+
+### diego_DAS.nf
+
+    for pdfile in $pdf ; do convert -verbose -density 500 -resize '800' \$pdfile \${pdfile%pdf}png; done
+    
+
+### diego_DAS.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DASENV --loglevel DEBUG 2>> log
+    
+
+### diego_DAS.nf
+
+    echo "$de DONE"
+    
+
+### dorado.nf
+
+    $CALLERBIN download --model $MODELPARAMS &> $ol && $CALLERBIN basecaller $CALLERPARAMS $MODELPARAMS . 2>> $ol 1> tmp.bam && samtools view -h tmp.bam|samtools fastq -n - | pigz 1> $oc 2>> $ol && rm -rf tmp.bam
+    
+
+### drimseq_DTU.nf
+
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME drimseq.idx
+    
+
+### drimseq_DTU.nf
+
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    
+
+### drimseq_DTU.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    
+
+### drimseq_DTU.nf
+
+    echo "$de DONE"
+    
+
+### dtu_base.nf
+
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        
+
+### dtu_base.nf
+
+        $COUNTBIN $COUNTPARAMS quant -p ${task.cpus} -i $idx $stranded -o $fn -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        
+
+### dtu_base.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DTUENV --loglevel DEBUG 2>> log
+    
+
+### dtu_base.nf
+
+    mkdir -p termdirs; for f in *_counts.gz; do b=\${f%_counts.gz}; mkdir -p termdirs/\$b; zcat \$f > termdirs/\$b/quant.sf; done 2> $lf; dirs=\$(ls -d termdirs/*); for d in \$dirs; do terminus group $RUNTERMINUS -d \$d -o termout &>> $lf; done; terminus collapse -d \$dirs -o termout &>> $lf; for d in \$dirs; do b=\$(basename \$d); gzip -c termout/\$b/quant.sf > \${b}_counts.gz; done 2>> $lf
+    
+
+### edger_DAS.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### edger_DAS.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DASREPS --ids -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### edger_DAS.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DASCOMP $PCOMBO ${task.cpus} $DASPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    
+
+### edger_DAS.nf
+
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    
+
+### edger_DAS.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DASENV --loglevel DEBUG 2>> log
+    
+
+### edger_DAS.nf
+
+    echo "$de DONE"
+    
+
+### edger_DE.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(gzip -cdfq $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### edger_DE.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### edger_DE.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    
+
+### edger_DE.nf
+
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    
+
+### edger_DE.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DEENV --loglevel DEBUG 2>> log
+    
+
+### edger_DE.nf
+
+    echo "$de DONE"
+    
+
+### edger_DEU.nf
+
+    mkdir -p TMP; $COUNTBIN -T ${task.cpus} $COUNTPARAMS $pair $stranded -a <(zcat $anno) -o tmpcts $reads 2> $ol && head -n2 tmpcts |gzip > $oc && export LC_ALL=C; tail -n+3 tmpcts|sort --parallel=${task.cpus} -S $sortmem -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> $oc 2>> $ol && mv tmpcts.summary $os
+    
+
+### edger_DEU.nf
+
+    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
+    ${BINS}/Analysis/build_count_table.py $DEUREPS --ids -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    
+
+### edger_DEU.nf
+
+    mkdir -p Figures Tables
+    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DEUCOMP $PCOMBO ${task.cpus} $DEUPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    
+
+### edger_DEU.nf
+
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    
+
+### edger_DEU.nf
+
+    touch log; python3 $BINS/Analysis/RmdCreator.py --files $inlist --output out.Rmd --env $DEUENV --loglevel DEBUG 2>> log
+    
+
+### edger_DEU.nf
+
+    echo "$de DONE"
+    
+
+### fastp.nf
+
+        $TRIMBIN $TRIMPARAMS --thread ${task.cpus} --in1 $r1 --in2 $r2 --out1 $o --out2 $p &> $r 
+        
+
+### fastp.nf
+
+        $TRIMBIN $TRIMPARAMS --threads ${task.cpus} --i $r1 --o $o &> $r 
+        
+
+### fastqc.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS -f bam $map
+    
+
+### fastqc.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_dedup.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_dedup.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_dedup_trim.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_dedup_trim.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_dedup_trim.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_raw.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_trim.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fastqc_trim.nf
+
+    fastqc --quiet -t ${task.cpus} $QCPARAMS --noextract -f fastq $read
+    
+
+### fgumi.nf
+
+            mkdir -p tmp && $DEDUPBIN extract $EXTRACTPARAMS --inputs $r1 $r2 --sample $sn --library $sn --output $ubam > ex.log 2>&1 && samtools fastq -n -1 $outf -2 $outf2 -0 /dev/null -s /dev/null $ubam >> ex.log 2>&1
+        
+
+### fgumi.nf
+
+            mkdir -p tmp && $DEDUPBIN extract $EXTRACTPARAMS --inputs $r1 --sample $sn --library $sn --output $ubam > ex.log 2>&1 && samtools fastq -n $ubam | gzip -c > $outf && echo done >> ex.log
+        
+
+### fgumi_dedup.nf
+
+    mkdir -p TMP
+    ref_dict=\$(basename $ref .gz).dict
+    if [[ ! -f "\${ref_dict}" ]]; then samtools dict $ref -o \${ref_dict} >> $outl 2>&1; fi
+    samtools sort -n -@ ${task.cpus} -o TMP/ubam_qn.bam $ubam >> $outl 2>&1
+    samtools sort -n -@ ${task.cpus} -o TMP/mapped_qn.bam $bams >> $outl 2>&1
+    samtools view -h TMP/mapped_qn.bam | awk 'BEGIN{FS=OFS="\t"} /^@/{print; next} {f=\$2+0; if (!and(f,256) && !and(f,2048)) {k=\$1":"(and(f,64)?1:0)":"(and(f,128)?1:0); if (seen[k]++) next} print}' | samtools view -b -o TMP/mapped_qn_primaryuniq.bam - >> $outl 2>&1
+    $DEDUPBIN zipper --unmapped TMP/ubam_qn.bam --input TMP/mapped_qn_primaryuniq.bam --reference $ref --output TMP/zippered.bam --threads ${task.cpus} --compression-level 1 >> $outl 2>&1
+    $DEDUPBIN sort --order template-coordinate --input TMP/zippered.bam --output TMP/sorted.bam --threads ${task.cpus} --compression-level 1 >> $outl 2>&1
+    $DEDUPBIN dedup $DEDUPPARAMS --input TMP/sorted.bam --output TMP/dedup.bam >> $outl 2>&1
+    $DEDUPBIN sort --order coordinate --input TMP/dedup.bam --output $outf --write-index --threads ${task.cpus} --compression-level 1 >> $outl 2>&1
+    
+
+### footer.nf
+
+    echo 'Workflow finished, no error'
+    
+
+### guppy.nf
+
+    mkdir -p TMP; echo \"${f5}\" > f5list && $CALLERBIN $CALLERPARAMS  -c $MODELPARAMS --compress_fastq -i . --input_file_list f5list -s TMP 2> $ol && cat TMP/pass/fastq_runid_*.fastq.gz > $oc && cat TMP/*.log >> $ol && mv -f TMP/sequencing_summary.txt . &&  mv -f TMP/sequencing_telemetry.js . && rm -rf TMP
+    
+
+### hisat2.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### hisat2.nf
+
+    zcat $gen > tmp.fa && mkdir -p $MAPUIDXNAME && $indexbin $IDXPARAMS -p ${task.cpus} tmp.fa $MAPUIDXNAME/$MAPPREFIX  &> index.log && ln -fs $MAPUIDXNAME hisat2.idx
+    
+
+### hisat2.nf
+
+        $MAPBIN $MAPPARAMS $stranded -p ${task.cpus} -x ${idx}/${MAPPREFIX} -1 $r1 -2 $r2 --un-conc-gz ${fn}.unmapped -S $pf &> $lf && gzip $pf && touch $ufo $uft && rename 's/.unmapped.([1|2]).gz/_R\$1_unmapped.fastq.gz/' ${fn}.unmapped.*.gz  &>> $lf
+        
+
+### hisat2.nf
+
+        $MAPBIN $MAPPARAMS $stranded -p ${task.cpus} -x ${idx}/${MAPPREFIX} -U $read --un-gz $uf -S $pf &> $lf && gzip $pf && touch $uf &>> $lf
+        
+
+### kallisto.nf
+
+        ln -sf $r1 $b ; ln -sf $r2 $c; echo "simulated $r1 $r2 trimming" > $a
+        
+
+### kallisto.nf
+
+        ln -sf $reads $b ; echo "simulated $reads trimming" > $a
+        
+
+### kallisto.nf
+
+    $COUNTBIN index $IDXPARAMS $decoy -t ${task.cpus} -i $COUNTUIDXNAME $gen &> index.log && ln -fs $COUNTUIDXNAME kallisto.idx
+    
+
+### kallisto.nf
+
+        $COUNTBIN quant -t ${task.cpus} -i $idx $stranded $COUNTPARAMS -o $fn $r1 $r2 &>> $lf && gzip $of && ln -fs $oz $ol && ln -fs ${fn}/run_info.json ${fn}_run_info.json && ln -fs ${fn}/abundance.h5 ${fn}_abundance.h5
+        
+
+### kallisto.nf
+
+         $COUNTBIN quant -t ${task.cpus} -i $idx $stranded $COUNTPARAMS -o $fn --single $read &>> $lf && gzip $of && ln -fs $oz $ol && ln -fs ${fn}/run_info.json ${fn}_run_info.json && ln -fs ${fn}/abundance.h5 ${fn}_abundance.h5
+        
+
+### macs2.nf
+      
+    set +o pipefail; export LC_ALL=C; if [[ -n \"\$(samtools view $bf | head -c 1 | tr '\\0\\n' __)\" ]] ;then $PEAKSBIN callpeak -t $bf $bc --outdir . -n $of -f $mapmode $PEAKSPARAMS 2> $ol && gzip *_peaks.narrowPeak 2>> $ol && mv -f *_peaks.narrowPeak.gz $oz 2>> $ol; else gzip < /dev/null > $oz; echo \"File $bam empty\" >> $ol; fi
+    
+
+### macs2.nf
+
+    perl $BINS/Universal/Bed2Bedgraph.pl -f <(zcat $bed) -c $sizes -p peak -x tmp.fw.gz -y tmp.re.gz -a track 2>> $ol && zcat tmp.fw.gz | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2>> $ol && zcat tmp.re.gz |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### macs2.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### macs2.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### macs2.nf
+
+    mkdir -p LOGS;touch LOGS/MONSDA.log; bf=($bwf); br=($bwr); blen=\${#bf[@]}; for i in \"\${!bf[@]}\";do f=\${bf[\$i]}; r=\${br[\$i]}; echo -e \"\$f\\n\$r\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"TRACKS/$SETS\" -g $REFDIR $opt 2>> $ol;done
+    
+
+### macs3.nf
+      
+    set +o pipefail; export LC_ALL=C; if [[ -n \"\$(samtools view $bf | head -c 1 | tr '\\0\\n' __)\" ]] ;then $PEAKSBIN callpeak -t $bf $bc --outdir . -n $of -f $mapmode $PEAKSPARAMS 2> $ol && gzip *_peaks.narrowPeak 2>> $ol && mv -f *_peaks.narrowPeak.gz $oz 2>> $ol; else gzip < /dev/null > $oz; echo \"File $bam empty\" >> $ol; fi
+    
+
+### macs3.nf
+
+    perl $BINS/Universal/Bed2Bedgraph.pl -f <(zcat $bed) -c $sizes -p peak -x tmp.fw.gz -y tmp.re.gz -a track 2>> $ol && zcat tmp.fw.gz | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2>> $ol && zcat tmp.re.gz |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### macs3.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### macs3.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### macs3.nf
+
+    mkdir -p LOGS;touch LOGS/MONSDA.log; bf=($bwf); br=($bwr); blen=\${#bf[@]}; for i in \"\${!bf[@]}\";do f=\${bf[\$i]}; r=\${br[\$i]}; echo -e \"\$f\\n\$r\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"TRACKS/$SETS\" -g $REFDIR $opt 2>> $ol;done
+    
+
+### manipulate_genome.nf
+
+    zcat $ref |perl -F'\\t' -wane 'if(\$_ =~ /^>/){{chomp(\$F[0]);print \"\\n\".\$F[0].\"\\n\"}} else{{(\$line=\$_)=~s/\\r[\\n]*/\\n/gm; chomp(\$line=\$_); print \$line}}' |tail -n+2 > $fa && $BINS/Preprocessing/indexfa.sh $fa 2> log && cut -f1,2 $fai > $cs
+    
+
+### manipulate_genome.nf
+
+    zcat $ref |perl -F'\\t' -wane 'if(\$_ =~ /^>/){{\$F[0] = \$F[0] =~ /^>chr/ ? \$F[0] : \">chr\".substr(\$F[0],1) =~ s/_/./g;chomp(\$F[0]);print \"\\n\".\$F[0].\"\\n\"}} else{{(\$line=\$_)=~s/\\r[\\n]*/\\n/gm; chomp(\$line=\$_); print \$line}}' |tail -n+2 > $fa && $BINS/Preprocessing/indexfa.sh $fa 2> log && cut -f1,2 $fai > $cs
+    
+
+### mapping.nf
+
+    set +o pipefail; mkdir -p TMP; samtools view -H $map|grep -P '^@HD' |pigz -p ${task.cpus} -f > tmphead; samtools view -H $map|grep -P '^@SQ'|sort -t\$'\\t' -k1,1 -k2,2V |pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@RG'|pigz -p ${task.cpus} -f >> tmphead ; samtools view -H $map|grep -P '^@PG'|pigz -p ${task.cpus} -f >> tmphead ; export LC_ALL=C;zcat $map | grep -v \"^@\"|sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k3,3V -k4,4n - |pigz -p ${task.cpus} -f > tmpfile; cat tmphead tmpfile > $sorted && rm -f tmphead tmpfile
+    
+
+### mapping.nf
+
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> sam2bam.log
+    
+
+### mapping.nf
+
+    $BINS/Shells/UniqueSam_woPicard.sh $sam $uniq ${task.cpus} $bwa 2> uniq.log
+    
+
+### mapping.nf
+
+    zcat $sam | samtools view -bS - | samtools sort -T $fn -o $bam --threads ${task.cpus} && samtools index $bam 2> uniquebam.log
+    
+
+### minimap.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### minimap.nf
+
+    $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS $gen &> index.log && ln -fs $MAPUIDXNAME minimap.idx
+    
+
+### minimap.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> {log} &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### minimap.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### multiqc.nf
+
+    touch $others
+    OUT=\${PWD}
+    LOGDIR="${workflow.workDir}/../LOGS"
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
+
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
+    fi
+
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
+    export LC_ALL=C.UTF-8
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
+    
+
+### multiqc_rustqc.nf
+
+    touch $others
+    OUT=\${PWD}
+    LOGDIR="${workflow.workDir}/../LOGS"
+    BASE_QC_DIR="${workflow.workDir}/../QC"
+    COMBO_VAL="${COMBO}"
+    CONDITION_VAL="${CONDITION}"
+    VERSIONS="\${LOGDIR}/versions.txt"
+    SCAN="\${LOGDIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+
+    # All QC results of this combo are reported, no need to collect them first.
+    QC_DIR="\${BASE_QC_DIR}/\${COMBO_VAL}/\${CONDITION_VAL}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
+
+    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
+        SCAN="\$SCAN \$FQ_DIR"
+    fi
+
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
+    export LC_ALL=C.UTF-8
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
+    
+
+### notify.nf
+
+    markdown_to_html.py $output_docs -o results_description.html
+    
+
+### oarfish.nf
+
+    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $COUNTANNO --genome-fasta $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
+    
+
+### peaks.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/1\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### peaks.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/2\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### peaks.nf
+        
+    $BINS/Universal/ExtendBed.pl $opt -b $bed -o $of -g $sizes 2> $ol
+    
+
+### peaks.nf
+
+    export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i $bed -bg -split -strand + -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"+\")' > tosrt 2> $ol && bedtools genomecov -i $bed -bg -split -strand - -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"-\")' >> tosrt 2>> $ol && cat tosrt | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $of 2>> $ol
+    
+
+### peaks.nf
+        
+    perl $BINS/Analysis/PreprocessPeaks.pl -p <(zcat $bed) $PREPARAMS | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k3,3n -k2,2n -k6,6 |gzip > $of 2> $ol
+    
+
+### peaks.nf
+        
+    perl $BINS/Analysis/FindPeaks.pl $PEAKSPARAMS -p <(zcat $bed) 2> $ol | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $of 2>> $ol
+    
+
+### peaks.nf
+
+    perl $BINS/Universal/Bed2Bedgraph.pl -f <(zcat $bed) -c $sizes -p peak -x tmp.fw.gz -y tmp.re.gz -a track 2>> $ol && zcat tmp.fw.gz | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2>> $ol && zcat tmp.re.gz |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### peaks.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### peaks.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### peaks.nf
+
+    mkdir -p LOGS;touch LOGS/MONSDA.log; bf=($bwf); br=($bwr); blen=\${#bf[@]}; for i in \"\${!bf[@]}\";do f=\${bf[\$i]}; r=\${br[\$i]}; echo -e \"\$f\\n\$r\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"TRACKS/$SETS\" -g $REFDIR $opt 2>> $ol;done
+    
+
+### picard_dedup.nf
+
+    mkdir -p TMP && $DEDUPBIN $JAVAPARAMS MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR TMP --INPUT $bams --OUTPUT $outf --METRICS_FILE $outm $DEDUPPARAMS &> $outl && samtools index $outf &>> $outl
+    
+
+### piranha.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/1\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### piranha.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/2\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### piranha.nf
+        
+    $BINS/Universal/ExtendBed.pl $opt -b $bed -o $of -g $sizes 2> $ol
+    
+
+### piranha.nf
+
+    export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i $bed -bg -split -strand + -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"+\")' > tosrt 2> $ol && bedtools genomecov -i $bed -bg -split -strand - -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"-\")' >> tosrt 2>> $ol && cat tosrt | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $of 2>> $ol
+    
+
+### piranha.nf
+        
+    perl $BINS/Analysis/PreprocessPeaks.pl -p <(zcat $bed) $PREPARAMS | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k3,3n -k2,2n -k6,6 |gzip > $of 2> $ol
+    
+
+### piranha.nf
+  
+    export LC_ALL=C; if [[ -n \"\$(zcat $bed | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then $PEAKSBIN $PEAKSPARAMS <(zcat $bed|sort -t\$\'\\t\' -k1,1 -k3,3n -k2,2n -k6,6) 2> $ol|tail -n+2| sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$\'\\t\' -k1,1 -k2,2n |grep -v \'nan\'| gzip > $of 2>> $ol; else gzip < /dev/null > $of; echo \"File $bed empty\" >> $ol; fi
+    
+
+### piranha.nf
+
+    perl $BINS/Universal/Bed2Bedgraph.pl -f <(zcat $bed) -c $sizes -p peak -x tmp.fw.gz -y tmp.re.gz -a track 2>> $ol && zcat tmp.fw.gz | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2>> $ol && zcat tmp.re.gz |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### piranha.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### piranha.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### piranha.nf
+
+    mkdir -p LOGS;touch LOGS/MONSDA.log; bf=($bwf); br=($bwr); blen=\${#bf[@]}; for i in \"\${!bf[@]}\";do f=\${bf[\$i]}; r=\${br[\$i]}; echo -e \"\$f\\n\$r\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"TRACKS/$SETS\" -g $REFDIR $opt 2>> $ol;done
+    
+
+### piscem.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### piscem.nf
+
+    mkdir -p $MAPUIDXNAME && zcat $gen > ref.fa && $MAPBIN build -t ${task.cpus} $IDXPARAMS -s ref.fa -o $MAPUIDXNAME/$MAPPREFIX &> index.log && rm -f ref.fa && ln -fs $MAPUIDXNAME piscem.idx
+    
+
+### piscem.nf
+
+    $MAPBIN map-sc -t ${task.cpus} $MAPPARAMS -i $idxdir/$MAPPREFIX -1 $r1 -2 $r2 -o $of &> $lf
+    
+
+### premultiqc.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### premultiqc.nf
+
+    OUT=\${PWD}
+    LOGDIR="${workflow.workDir}/../LOGS"
+    SCAN="\${LOGDIR}/${CONDITION}"
+    VERSIONS="\${LOGDIR}/versions.txt"
+
+    # All QC results of this condition are reported, no need to collect them first.
+    QC_DIR="${workflow.workDir}/../QC/${CONDITION}"
+    if [[ -d "\$QC_DIR" ]]; then
+        SCAN="\$SCAN \$QC_DIR"
+    fi
+
+    MODS=""
+    if [[ -f "\$VERSIONS" ]]; then
+        MODS=\$(grep -v '^#' "\$VERSIONS" | cut -f3 | tr ',' '\\n' | grep -vx '-' | sort -u | sed 's/^/-m /' | tr '\\n' ' ')
+        cp -f "\$VERSIONS" "\$OUT"/
+    fi
+    export LC_ALL=C.UTF-8
+    multiqc -f $MQCPARAMS \$MODS -k json -z -s -o "\$OUT" \$SCAN
+    
+
+### rammap.nf
+
+    gzip -cdfq $gen > tmp_ref.fa && $MAPBIN -t ${task.cpus} -d $MAPUIDXNAME $IDXPARAMS tmp_ref.fa &> index.log && rm -f tmp_ref.fa && ln -fs $MAPUIDXNAME rammap.idx
+    
+
+### rammap.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $r1 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### rammap.nf
+
+        $MAPBIN $MAPPARAMS -t ${task.cpus} $idx $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### rastqc.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $map
+    FILE=\$(basename "$map")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_dedup.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_dedup.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_dedup_trim.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_dedup_trim.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_dedup_trim.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_raw.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_trim.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rastqc_trim.nf
+
+    rastqc --quiet --extract -t ${task.cpus} $QCPARAMS $read
+    FILE=\$(basename "$read")
+    BASE=\${FILE%.gz}
+    BASE=\${BASE%.*}_fastqc
+    sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' "\$BASE/fastqc_data.txt"
+    rm "\$BASE.zip"
+    python -m zipfile -c "\$BASE.zip" "\$BASE"
+    
+
+### rustar.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### rustar.nf
+
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir RUSTARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME rustar.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf RUSTARTMP
+    
+
+### rustar.nf
+
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        
+
+### rustar.nf
+
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            
+
+### rustar.nf
+
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            
+
+### rustqc.nf
+
+    mkdir -p results/$fn && gzip -cdfq $anno > tmp_anno.gtf && $RUSTQCBIN rna $bam --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/$fn/rustqc_summary.json -o results/$fn $RUSTQCPARAMS && rm -f tmp_anno.gtf
+    
+
+### salmon.nf
+
+        ln -sf $r1 $b ; ln -sf $r2 $c; echo "simulated $r1 $r2 trimming" > $a
+        
+
+### salmon.nf
+
+        ln -sf $reads $b ; echo "simulated $reads trimming" > $a
+        
+
+### salmon.nf
+
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $COUNTUIDXNAME &> index.log && ln -fs $COUNTUIDXNAME salmon.idx
+    
+
+### salmon.nf
+
+        $COUNTBIN quant -p ${task.cpus} -i $idx $stranded -o $fn $COUNTPARAMS -1 $r1 -2 $r2 &>> $lf && gzip $of && ln -fs $oz $ol
+        
+
+### salmon.nf
+
+        $COUNTBIN quant -p ${task.cpus} -i $idx $stranded -o $fn $COUNTPARAMS -r $read &>> $lf && gzip $of && ln -fs $oz $ol
+        
+
+### salmon.nf
+
+        mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN quant -p ${task.cpus} -a namecollated.bam --annotation $COUNTANNO --genome $COUNTREF $COUNTPARAMS -o $fn &>> $lf && rm -f namecollated.bam && gzip $of && ln -fs $oz $ol
+        
+
+### salmon.nf
+
+        mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN quant -p ${task.cpus} -t $COUNTREF -a namecollated.bam --deterministic $COUNTPARAMS -o $fn &>> $lf && rm -f namecollated.bam && gzip $of && ln -fs $oz $ol
+        
+
+### salmonalign.nf
+
+    $MAPBIN index $IDXPARAMS -p ${task.cpus} -t $gen -i $MAPUIDXNAME &> index.log && ln -fs $MAPUIDXNAME salmonalign.idx
+    
+
+### salmonalign.nf
+
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings=/dev/stdout -o $fn -1 $r1 -2 $r2 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 2>> $lf &> /dev/null
+        
+
+### salmonalign.nf
+
+        $MAPBIN quant -p ${task.cpus} -i $idx $stranded $MAPPARAMS --writeMappings=/dev/stdout -o $fn -r $read 2> $lf|tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### scyphy.nf
+
+    mkdir -p TMP/$fn; p=\$( dirname \$(realpath \"$bam\") ); ln -s \${p}/${fn}.bam.bai .; python $BINS/Analysis/RemoveSoftClip.py -f $REF -b $bam $SOFTPARAMS -o \'-\' | samtools sort -T TMP/$fn -o $fo --threads ${task.cpus} \'-\' 2>> $ol && samtools index $fo 2>> $ol && mv $ol ${fn}.log; rm -rf TMP/$fn
+    
+
+### scyphy.nf
+
+        p=\$( dirname \$(realpath \"$bam\") ); ln -s \${p}/${fn}.bam.bai .;
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/1\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### scyphy.nf
+
+        p=\$( dirname \$(realpath \"$bam\") ); ln -s \${p}/${fn}.bam.bai .;
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/2\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### scyphy.nf
+        
+    $BINS/Universal/ExtendBed.pl $opt -b $bed -o $of -g $sizes 2> $ol
+    
+
+### scyphy.nf
+        
+    $BINS/Universal/ExtendBed.pl $opt -b $bed -o $of -g $sizes 2> $ol
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i $bed -bg -split -strand + -g $sizes | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol && bedtools genomecov -i $bed -bg -split -strand - -g $sizes |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i $bed -bg -split -strand + -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"+\")' > tosrt && cat tosrt| sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol && bedtools genomecov -i $bed -bg -split -strand - -g $sizes | perl -wlane 'print join(\"\\t\",@F[0..2],\".\",\$F[3],\"-\")' > tosrt && cat tosrt|sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### scyphy.nf
+        
+    perl $BINS/Analysis/PreprocessPeaks.pl -p <(zcat $bedgf $bedgr| sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k3,3n -k2,2n -k6,6) $PREPARAMS | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k3,3n -k2,2n -k6,6 |gzip > $of 2> $ol
+    
+
+### scyphy.nf
+  
+    export LC_ALL=C; if [[ -n \"\$(zcat $bed | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then $PEAKSBIN $PEAKSPARAMS <(zcat $bed|sort -t\$\'\\t\' -k1,1 -k3,3n -k2,2n -k6,6) 2> $ol|tail -n+2| sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$\'\\t\' -k1,1 -k2,2n |grep -v \'nan\'| gzip > $of 2>> $ol; else gzip < /dev/null > $of; echo \"File $bed empty\" >> $ol; fi
+    
+
+### scyphy.nf
+  
+    export LC_ALL=C; mkdir -p TMP; if [[ -n \"\$(zcat $pk | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then  zcat $pk | perl -wlane '\$F[0] = \$F[0] =~ /^chr/ ? \$F[0] : \"chr\".\$F[0]; print join(\"\\t\",@F[0..5])' > pktmp && bedtools getfasta -fi $fa -bed pktmp -name -tab -s -fullHeader -fo pkseqtmp && cut -d\$'\\t' -f2 pkseqtmp|sed 's/t/u/ig'|paste -d\$'\\t' <(zcat pktmp) - |sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip  > $of 2> $ol; else gzip < /dev/null > $of; echo \"File $pk empty\" >> $ol; fi
+    
+
+### scyphy.nf
+
+    mkdir -p TMP/fw TMP/re ; perl $BINS/Universal/Bed2Bedgraph.pl -f <(zcat $bed) -c $sizes -p peak -x tmp.fw.gz -y tmp.re.gz -a track 2>> $ol && zcat tmp.fw.gz | sort --parallel=${task.cpus} -S $sortmem -T TMP/fw -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2>> $ol && zcat tmp.re.gz |sort -S $sortmem -T TMP/re -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### scyphy.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### scyphy.nf
+
+    bf=($pkbw[0]); br=($pkbw[1]); mf=($mapbw[0]); mr=($mapbw[1]); for i in \"\${!bf[@]}\";do fp=\${bf[\$i]}; rp=\${br[\$i]}; fm=\${mf[\$i]}; rm=\${mr[\$i]}; echo -e \"\$fp\\n\$rp\\n\$fm\\n\$rm\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"\" -g $REFDIR $opt 2>> $ol;done
+    
+
+### segemehl.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### segemehl.nf
+
+    $MAPBIN $IDXPARAMS --threads ${task.cpus} -d $gen -x $MAPUIDXNAME &> index.log && ln -s $MAPUIDXNAME segemehl.idx
+    
+
+### segemehl.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -d $gen -q $r1 -p $r2  2> $lf| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2
+        
+
+### segemehl.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -d $gen -q $read 2> $lf| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### segemehl3.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### segemehl3.nf
+
+    $MAPBIN $IDXPARAMS --threads ${task.cpus} -d $gen -x $MAPUIDXNAME &> index.log && ln -s $MAPUIDXNAME segemehl3.idx
+    
+
+### segemehl3.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -d $gen -q $r1 -p $r2  2> $lf| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2
+        
+
+### segemehl3.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -d $gen -q $read 2> $lf| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### segemehl3_bisulfite.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### segemehl3_bisulfite.nf
+
+    $MAPBIN $IDXPARAMS --threads ${task.cpus} -d $gen -x $MAPUIDXNAME -y $MAPUIDX2NAME &> index.log && ln -s $MAPUIDXNAME segemehl3bisulfite.idx && ln -s $MAPUIDX2NAME segemehl3bisulfite_bs.idx2
+    
+
+### segemehl3_bisulfite.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -j $idx2 -d $gen -q $r1 -p $r2 2> $lf | tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2
+        
+
+### segemehl3_bisulfite.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -j $idx2 -d $gen -q $read 2> $lf| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf
+        
+
+### segemehl_bisulfite.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### segemehl_bisulfite.nf
+
+    $MAPBIN $IDXPARAMS --threads ${task.cpus} -d $gen -x $MAPUIDXNAME -y $MAPUIDX2NAME &> index.log && ln -s $MAPUIDXNAME segemehlbisulfite.idx && ln -s $MAPUIDX2NAME segemehlbisulfite_bs.idx2
+    
+
+### segemehl_bisulfite.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -j $idx2 -d $gen -q $r1 -p $r2 -o tmp.sam 2> $lf && cat tmp.sam| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 $uf1 -2 $uf2 ) 2>> $lf &>/dev/null && touch $uf1 $uf2 && rm -f tmp.sam
+        
+
+### segemehl_bisulfite.nf
+
+        $MAPBIN $MAPPARAMS --threads ${task.cpus} -i $idx -j $idx2 -d $gen -q $read -o tmp.sam 2> $lf && cat tmp.sam| tee >(samtools view -h -F 4 |gzip > $pf) >(samtools view -h -f 4 |samtools fastq -n - | pigz > $uf) 2>> $lf &> /dev/null && touch $uf && rm -f tmp.sam
+        
+
+### simpleaf.nf
+
+    export ALEVIN_FRY_HOME=\$PWD/af_home; mkdir -p \$ALEVIN_FRY_HOME; $COUNTBIN set-paths &> index.log; zcat $gen > ref.fa && zcat $an > ref.gtf && $COUNTBIN index --fasta ref.fa --gtf ref.gtf -t ${task.cpus} $IDXPARAMS -o $COUNTUIDXNAME &>> index.log && rm -f ref.fa ref.gtf && ln -fs $COUNTUIDXNAME simpleaf.idx
+    
+
+### simpleaf.nf
+
+    export ALEVIN_FRY_HOME=\$PWD/af_home; mkdir -p \$ALEVIN_FRY_HOME; $COUNTBIN set-paths &> $lf; $COUNTBIN quant --index $idx/index --reads1 $r1 --reads2 $r2 -t ${task.cpus} $COUNTPARAMS -o $qd &>> $lf
+    
+
+### simulatetrim.nf
+
+        ln -sf $r1 $b ; ln -sf $r2 $c; echo "simulated $r1 $r2 trimming" > $a
+        
+
+### simulatetrim.nf
+
+        ln -sf $reads $b ; echo "simulated $reads trimming" > $a
+        
+
+### spit_DTU.nf
+
+    $COUNTBIN index $IDXPARAMS $decoy -p ${task.cpus} -t $gen -i $DTUUIDXNAME &> index.log && ln -fs $DTUUIDXNAME spit.idx
+    
+
+### spit_DTU.nf
+
+    mkdir -p TMP; $BINS/Analysis/build_DTU_table.py $DTUREPS --anno $ca --loglevel DEBUG --nextflow 2>> $ol
+    
+
+### spit_DTU.nf
+
+    mkdir -p Figures Tables
+    python3 $bin $anno $ref . $DTUCOMP $PCOMBO ${task.cpus} $dparams &> log ; ln -f Tables/* . && touch Figures/dummy && ln -f Figures/* .
+    
+
+### spit_DTU.nf
+
+    echo "$de DONE"
+    
+
+### sra.nf
+
+        export NCBI_SETTINGS=\"$FETCHPARAMS\"
+        prefetch $reads -o $fn &> prefetch.log
+        
+
+### sra.nf
+
+        export NCBI_SETTINGS=\"$FETCHPARAMS\"
+        fasterq-dump -e ${task.cpus} $DOWNPARAMS --split-files $sras &> sra.log ; rename 's/(.sra)*_([1|2])/_R\$2/' *.fastq; for i in *.fastq;do pigz -p ${task.cpus} \$i;done
+        
+
+### sra.nf
+
+        export NCBI_SETTINGS=\"$FETCHPARAMS\"
+        fasterq-dump -e ${task.cpus} $DOWNPARAMS $sras &> sra.log ; rename 's/(.sra)*_([1|2])/_R\$2/' *.fastq ; for i in *.fastq;do pigz -p ${task.cpus} \$i;done
+        
+
+### star.nf
+
+    echo "$check Collection successful!" > collect.txt
+    
+
+### star.nf
+
+    zcat $gen > tmp.fa && zcat $an > tmp_anno && mkdir -p $MAPUIDXNAME && rm -rf STARTMP && $MAPBIN $IDXPARAMS --runThreadN ${task.cpus} --runMode genomeGenerate --outTmpDir STARTMP --genomeDir $MAPUIDXNAME --genomeFastaFiles tmp.fa && touch $MAPUIDXNAME && ln -s $MAPUIDXNAME star.idx && rm -f tmp.fa tmp_anno && ln -fs $MAPUIDXNAME/* . && rm -rf STARTMP
+    
+
+### star.nf
+
+        $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2 --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && cat ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+        
+
+### star.nf
+
+            $MAPBIN $MAPPARAMS --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $read --outFileNamePrefix $fn --outReadsUnmapped Fastx && gzip -c $of > $gf && rm -f $of && gzip *Unmapped.out* && for f in *mate*.gz; do mv "\$f" "\$(echo "\$f" | sed -r 's/\\.Unmapped.out.mate1.gz/_unmapped.fastq.gz/')"; done && mv *Log.out ${fn}_mapping.log
+            
+
+### star.nf
+
+            $MAPBIN $MAPPARAMS $stranded --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN ${task.cpus} --genomeDir $idxdir --readFilesCommand zcat --readFilesIn $r1 $r2  --outFileNamePrefix ${fn}. --outReadsUnmapped Fastx && samtools view -h ${of} | gzip > $gf && rm -f $of && touch ${fn}.Unmapped.out.mate1 ${fn}.Unmapped.out.mate2 && cat ${fn}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R1_unmapped.fastq.gz && at ${fn}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > ${fn}_R2_unmapped.fastq.gz && mv *Log.out ${fn}_mapping.log
+            
+
+### starfusion.nf
+
+    if [[ -f \"$FUSLIBDIR/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR\"; elif [[ -f \"$FUSLIBDIR/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> ${ol}; fi; if [[ -s \"${junction}\" ]]; then ctat_chr=\$(grep -v '^#' \$CTAT/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=\$(awk '!/^#/ && \$1!=\"chr_donorA\"{print \$1; exit}' ${junction} | grep -c '^chr' || true); if [[ \"\$ctat_chr\" == \"1\" && \"\$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {if(\$1!~/^chr/)\$1=\"chr\"\$1; if(\$4!~/^chr/)\$4=\"chr\"\$4; if(\$1==\"chrMT\")\$1=\"chrM\"; if(\$4==\"chrMT\")\$4=\"chrM\"; print}' ${junction} > ${fn}.norm.junction; elif [[ \"\$ctat_chr\" == \"0\" && \"\$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> ${ol}; awk 'BEGIN{OFS=\"\\t\"} /^#/{print;next} \$1==\"chr_donorA\"{print;next} {sub(/^chr/,\"\",\$1); sub(/^chr/,\"\",\$4); if(\$1==\"M\")\$1=\"MT\"; if(\$4==\"M\")\$4=\"MT\"; print}' ${junction} > ${fn}.norm.junction; else cp ${junction} ${fn}.norm.junction; fi; $FUSBIN --genome_lib_dir \$CTAT -J ${fn}.norm.junction --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> ${ol}; else mkdir -p ${od}; echo \"File ${junction} empty, no chimeric STAR output found\" >> ${ol}; fi; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    
+
+### starfusion.nf
+
+    if [[ -f \"$FUSLIBDIR/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR\"; elif [[ -f \"$FUSLIBDIR/ctat_genome_lib_build_dir/ref_annot.gtf\" ]]; then CTAT=\"$FUSLIBDIR/ctat_genome_lib_build_dir\"; else CTAT=CTAT; ( mkdir -p \$CTAT && zcat ${ref} > ctat_ref.fa && zcat ${anno} > ctat_ref.gtf && prep_genome_lib.pl --genome_fa ctat_ref.fa --gtf ctat_ref.gtf --output_dir \$CTAT --CPU ${task.cpus} $FUSBUILD ) &> ${ol}; fi; $FUSBIN --genome_lib_dir \$CTAT ${reads} --output_dir ${od} --CPU ${task.cpus} $FUSPARAMS &>> ${ol}; mkdir -p ${od}; touch ${od}/star-fusion.fusion_predictions.tsv ${od}/star-fusion.fusion_predictions.abridged.tsv
+    
+
+### summary.nf
+
+    ln -f \"${projectDir}/../REPORTS/SUMMARY/summary.Rmd\" .;
+    touch log;
+    Rscript --vanilla -e \"rmarkdown::render('summary.Rmd', params=list(root='.'), output_file='SUMMARY.html', quiet=TRUE)\" 2> log
+    
+
+### trimgalore.nf
+
+        $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        
+
+### trimgalore.nf
+
+        $TRIMBIN --cores ${task.cpus} --gzip $TRIMPARAMS $reads &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/.fq.gz/.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
+        
+
+### ucsc.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/1\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### ucsc.nf
+
+        bedtools bamtobed -split -i $bam | sed 's/ /_/g' | perl -wl -a -F'\\t' -n -e '\$F[0] =~ s/\\s/_/g;if(\$F[3]=~/\\/2\$/){{if (\$F[5] eq \"+\"){{\$F[5] = \"-\"}}elsif(\$F[5] eq \"-\"){{\$F[5] = \"+\"}}}} print join(\"\\t\",@F[0..\$#F])' | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fo 2> $ol
+        
+
+### ucsc.nf
+
+    export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i $bed -bg -split -strand + -g $sizes | sort --parallel=${task.cpus} -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol && bedtools genomecov -i $bed -bg -split -strand - -g $sizes |sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fr 2>> $ol
+    
+
+### ucsc.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgf|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgf)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n |gzip > $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=\$(bc <<< \"scale=6;\$(zcat $bedgr|cut -f4|perl -wne '{\$x+=\$_;}END{if (\$x == 0){\$x=1} print \$x}')/1000000\") perl -wlane '\$sc=\$ENV{scale};print join(\"\\t\",@F[0..\$#F-1]),\"\\t\",\$F[-1]/\$sc' <(zcat $bedgr)| sort -S $sortmem -T TMP -t\$'\\t' -k1,1 -k2,2n|gzip > $fr 2> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### ucsc.nf
+
+    export LC_ALL=C; if [[ -n \"\$(zcat $bedgf | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgf > tmp && bedGraphToBigWig tmp $sizes $fw 2> $ol; else gzip < /dev/null > $fw; echo \"File $bedgf empty\" >> $ol; fi && if [[ -n \"\$(zcat $bedgr | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat $bedgr > tmp && bedGraphToBigWig tmp $sizes $fr 2>> $ol; else gzip < /dev/null > $fr; echo \"File $bedgr empty\" >> $ol; fi
+    
+
+### ucsc.nf
+
+    mkdir -p LOGS;touch LOGS/MONSDA.log; bf=($bwf); br=($bwr); blen=\${#bf[@]}; for i in \"\${!bf[@]}\";do f=\${bf[\$i]}; r=\${br[\$i]}; echo -e \"\$f\n\$r\"|python3 $BINS/Analysis/GenerateTrackDb.py -i $uid -e 1 -f STDIN -u \"TRACKS/$SETS\" -g $REFDIR $TRACKSPARAMS 2>> $ol;done
+    
+
+### umicollapse.nf
+
+        touch $outf
+        
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$r1 --read2-in=$r2 --stdout=$outf
+            
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$samples --stdout=$outf
+            
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2
+            
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools extract $EXTRACTPARAMS --whitelist=$wl --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2
+            
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$samples --stdout=$outf
+            
+
+### umicollapse.nf
+
+                mkdir tmp && umi_tools extract $EXTRACTPARAMS --whitelist=$wl --temp-dir tmp --log=ex.log --stdin=$samples --stdout=$outf
+            
+
+### umicollapse_dedup.nf
+
+            mkdir -p TMP && $DEDUPBIN bam -i $bams -o TMP/dedup.unsorted.bam --paired $DEDUPPARAMS > $outl 2>&1 && samtools sort -@ ${task.cpus} -o $outf TMP/dedup.unsorted.bam >> $outl 2>&1 && samtools index $outf >> $outl 2>&1
+        
+
+### umicollapse_dedup.nf
+
+            mkdir -p TMP && $DEDUPBIN bam -i $bams -o TMP/dedup.unsorted.bam $DEDUPPARAMS > $outl 2>&1 && samtools sort -@ ${task.cpus} -o $outf TMP/dedup.unsorted.bam >> $outl 2>&1 && samtools index $outf >> $outl 2>&1
+        
+
+### umitools.nf
+
+        touch $outf
+        
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$r1 --read2-in=$r2 --stdout=$outf
+            
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$samples --stdout=$outf
+            
+
+### umitools.nf
+
+                echo 'EXTRACT unset, linking input fastq(s) as-is' > ex.log
+                ln -sf \$(readlink -f $r1) $outf
+                ln -sf \$(readlink -f $r2) $outf2
+            
+
+### umitools.nf
+
+                echo 'EXTRACT unset, linking input fastq(s) as-is' > ex.log
+                ln -sf \$(readlink -f $samples) $outf
+            
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2
+            
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN extract $EXTRACTPARAMS --whitelist=$wl --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2
+            
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$samples --stdout=$outf
+            
+
+### umitools.nf
+
+                mkdir tmp && $DEDUPBIN extract $EXTRACTPARAMS --whitelist=$wl --temp-dir tmp --log=ex.log --stdin=$samples --stdout=$outf
+            
+
+### umitools_dedup.nf
+
+            mkdir tmp && $DEDUPBIN dedup $DEDUPPARAMS --temp-dir tmp --log=$outl --paired --stdin=$bams --stdout=$outf && samtools index $outf >> $outl
+        
+
+### umitools_dedup.nf
+
+            mkdir tmp && $DEDUPBIN dedup $DEDUPPARAMS --temp-dir tmp --log=$outl --stdin=$bams --stdout=$outf && samtools index $outf >> $outl
+        
+
diff --git a/tests/tool_audit/smk_shell_commands.txt b/tests/tool_audit/smk_shell_commands.txt
new file mode 100644
index 00000000..2835cd97
--- /dev/null
+++ b/tests/tool_audit/smk_shell_commands.txt
@@ -0,0 +1,1116 @@
+### alevinfry.smk
+mkdir -p $(dirname {output.t2g}); zcat {input.anno} | awk 'BEGIN{{FS=\"\\t\";OFS=\"\\t\"}} $3==\"transcript\"{{match($9,/transcript_id \"[^\"]+\"/); t=substr($9,RSTART+15,RLENGTH-16); match($9,/gene_id \"[^\"]+\"/); g=substr($9,RSTART+9,RLENGTH-10); print t,g}}' > {output.t2g} 2> {log}
+
+### alevinfry.smk
+{params.mapp} generate-permit-list -i {input.rad} -d fw {params.ppara} -o {params.quantdir} &> {log}; {params.mapp} collate -i {params.quantdir} -r {input.rad} -t {threads} &>> {log}; {params.mapp} quant -i {params.quantdir} -m {input.t2g} -t {threads} -r cr-like {params.cpara} -o {params.quantdir} --use-mtx &>> {log} && mkdir -p $(dirname {output.cnts}) && gzip -c {params.quantdir}/alevin/quants_mat.mtx > {output.cnts} 2>> {log}
+
+### annotatebed.smk
+ln -s {params.abs} {output}
+
+### annotatebed.smk
+ln -s {params.abs} {output}
+
+### annotatebed.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[0]} 2> {log} && bedtools bamtobed -split -i {input[1]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[1]} 2>> {log}
+
+### annotatebed.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[0]} 2> {log} && bedtools bamtobed -split -i {input[1]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |gzip > {output[1]} 2>> {log}
+
+### annotatebed.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b {input[0]} -a {params.anno} {params.annof} {params.annop} |gzip > {output[0]}
+
+### annotatebed.smk
+set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1);chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### annotatebed.smk
+set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### annotatebed.smk
+export LC_ALL=C; zcat {input.bd} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.bt} && bedtools getfasta -fi {input.fa} -bed {output.bt} -name+ -tab -s -fullHeader -fo {output.bs} && cut -d$'\t' -f2 {output.bs}|sed 's/t/u/ig'|paste -d$'\t' <(zcat {input.bd}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.bed}
+
+### annotatebed.smk
+export LC_ALL=C; zcat {input[0]}|perl -wlane 'print join(\"\t\",@F[0..6],$F[-3],$F[-2])' |bedtools merge -s -c 7,8,9 -o distinct -delim \"|\" |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n|gzip > {output[0]}
+
+### bbduk.smk
+{params.trim} t={threads} in1={input.r1} in2={input.r2} out1={output.o1} out2={output.o2} {params.tpara}
+
+### bbduk.smk
+mv {input.o1} {output.r1} && mv {input.o2} {output.r2}
+
+### bbduk.smk
+{params.trim} t={threads} in={input.r1} out={output.o1} {params.tpara}
+
+### bbduk.smk
+mv {input.o1} {output.r1}
+
+### bwa.smk
+if [[ -f \"{output.uidx}\\/*\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\" ; else {params.indexer} index -p {output.uidx} {params.ipara} {input.ref} 2> {log} && ln -fs {params.linkidx} {output.idx} && touch {output.uidx};fi
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.index} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### bwa.smk
+{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} > {output.sai1} 2>> {log} && {params.mapp} {params.mpara} -t {threads} {input.ref} {input.r2} > {output.sai2} 2>> {log} && touch {output.unmapped} && touch {output.mapped}
+
+### bwa.smk
+{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log} | tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} 2>> {log} && touch {output.unmapped} && touch {output.mapped}
+
+### bwa.smk
+{params.mapp1} aln {params.mpara} -t {threads} {input.ref} {input.query} > {output.sai} && {params.mapp} {params.mpara} {input.ref} {output.sai} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### bwa.smk
+{params.mapp} {params.mpara} {input.ref} {input.sai1} {input.sai2} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.ref} {input.r1} {input.r2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwa.smk
+{params.mapp} {params.mpara} -t {threads} {input.ref} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### bwa2.smk
+if [[ -f \"{output.uidx}\\/*\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\" ; else {params.indexer} index -p {output.uidx} {params.ipara} {input.ref} 2> {log} && ln -fs {params.linkidx} {output.idx} && touch {output.uidx};fi
+
+### bwa2.smk
+{params.mapp} mem {params.mpara} -t {threads} {input.index} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwa2.smk
+{params.mapp} mem {params.mpara} -t {threads} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### bwameth.smk
+if [[ -f \"{output.uidx}\" ]]; then ln -fs {params.linkidx} {output.idx} && touch {output.uidx} && echo \"Found bwa index, continue with mapping\";else zcat {input.ref} > {output.uidx} && {params.indexer} {output.uidx} {params.ipara} 2> {log} && ln -fs {params.linkidx} {output.idx};fi
+
+### bwameth.smk
+{params.mapp} {params.mpara} --threads {threads} --reference {input.uidx} {input.r1} {input.r2}  2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### bwameth.smk
+{params.mapp} {params.mpara} --threads {threads} --reference {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### ciri2.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.sam} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then mkdir -p {output.tmp} && zcat {input.sam}|samtools sort -n -@ {threads} -u -O sam -T {output.tmp} > {output.ts} && zcat {input.anno} > {output.ta} && zcat {input.ref} > {output.tf} && perl {params.circ} -I {output.ts} -O {output.circs} -F {output.tf} -T {threads} -A {output.ta} -G {log} {params.cpara} &>> {log}; else gzip < /dev/null > {output.circs}; echo \"File {input.sam} empty\" >> {log}; fi; touch CIRIerror.log && cat CIRIerror.log >> {log} && echo '' > CIRIerror.log && touch {output.circs} && mkdir -p {output.tmp}
+
+### countreads.smk
+arr=({input.r1}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > {output.r1};done 2>> {log} && arr=({input.r2}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > {output.r2};done 2>> {log}
+
+### countreads.smk
+arr=({input.r1}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > {output.r1};done 2>> {log}; arr=({input.r2}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > {output.r2};done 2>> {log}
+
+### countreads.smk
+arr=({input.r1}); orr=({output.r1});alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > ${{orr[$i]}};done 2>> {log}
+
+### countreads.smk
+arr=({input.r1}); orr=({output.r1}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do a=$(zcat ${{arr[$i]}}|wc -l ); echo $((a/4)) > ${{orr[$i]}};done 2>> {log}
+
+### countreads.smk
+export LC_ALL=C; arr=({input.m}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do samtools view -F 260 ${{arr[$i]}} | cut -d$'\t' -f1|sort --parallel={threads} -S {params.sortmem}G -T TMP -u |wc -l > {output.m} ;done 2>> {log}
+
+### countreads.smk
+export LC_ALL=C; arr=({input.u}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do samtools view -F 260 ${{arr[$i]}} | cut -d$'\t' -f1|sort --parallel={threads} -S {params.sortmem}G -T TMP -u |wc -l > {output.u} ;done 2>> {log}
+
+### countreads.smk
+export LC_ALL=C; arr=({input.m}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do samtools view -F 260 ${{arr[$i]}} | cut -d$'\t' -f1|sort --parallel={threads} -S {params.sortmem}G -T TMP -u |wc -l > {output.m} ;done 2>> {log}
+
+### countreads.smk
+export LC_ALL=C; arr=({input.u}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do samtools view -F 260 ${{arr[$i]}} | cut -d$'\t' -f1|sort --parallel={threads} -S {params.sortmem}G -T TMP -u |wc -l > {output.u} ;done 2>> {log}
+
+### countreads.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/
+
+### countreads.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/
+
+### countreads.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.s} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/
+
+### countreads.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.t} {input.u} 2> {log} && head -n2 {output.t} |gzip > {output.cts} && export LC_ALL=C; tail -n+3 {output.t}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.cts} && mv {output.t}.summary {output.cts}.summary && cp -f {output.cts}.summary $(dirname {log})/
+
+### countreads.smk
+arr=({input.f}); filtered=();for val in ${{arr[@]}}; do [[ \"$val\" == *\"{params.curfile}\"* ]] && filtered+=(\"$val\");done; arr=filtered; alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" > {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.t}); alen=${{#arr[@]}}; filtered=();for val in ${{arr[@]}}; do [[ \"$val\" == *\"{params.curfile}\"* ]] && filtered+=(\"$val\");done; arr=filtered; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.m}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.u}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.d}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.x}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done 2> {log}
+
+### countreads.smk
+{params.bins}/Analysis/build_count_table_simple.py -r {params.samples} --table {output.tbl} --anno {output.anno} 2> {log} && {params.bins}/Analysis/build_count_table_simple.py -r {params.samples_u} --table {output.tbl_u} --anno {output.anno_u} 2> {log} && {params.bins}/Analysis/build_count_table_simple.py -r {params.samples_d} --table {output.tbl_d} --anno {output.anno_d} 2> {log} && {params.bins}/Analysis/build_count_table_simple.py -r {params.samples_ud} --table {output.tbl_ud} --anno {output.anno_ud} 2> {log}
+
+### countreads.smk
+arr=({input.f}); filtered=();for val in ${{arr[@]}}; do [[ \"$val\" == *\"{params.curfile}\"* ]] && filtered+=(\"$val\");done; arr=filtered; alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" > {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.t}); filtered=();for val in ${{arr[@]}}; do [[ \"$val\" == *\"{params.curfile}\"* ]] && filtered+=(\"$val\");done; arr=filtered; alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.m}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done && arr=({input.u}); alen=${{#arr[@]}}; for i in \"${{!arr[@]}}\";do echo -ne \"${{arr[$i]}}\t\" >> {output} && if [[ -s ${{arr[$i]}} ]]; then cat ${{arr[$i]}} >> {output}; else echo '0' >> {output};fi;done 2> {log}
+
+### countreads.smk
+{params.bins}/Analysis/build_count_table_simple.py -r {params.samples} --table {output.tbl} --anno {output.anno} 2> {log} && {params.bins}/Analysis/build_count_table_simple.py -r {params.samples_u} --table {output.tbl_u} --anno {output.anno_u} 2> {log}
+
+### countreads.smk
+Rscript {params.bins} {input.counts} {output.cpm} {output.tpm} 2> {log}
+
+### cutadapt.smk
+{params.trim} {params.tpara} --cores {threads} -o {output.o1} -p {output.o2} {input.r1} {input.r2} &> {log}
+
+### cutadapt.smk
+mv {input.o1} {output.r1} && mv {input.o2} {output.r2}
+
+### cutadapt.smk
+{params.trim} {params.tpara} --cores {threads} -o {output.o1} {input.r1} > {log}
+
+### cutadapt.smk
+mv {input.o1} {output.r1}
+
+### deseq2_DE.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### deseq2_DE.smk
+{params.bins}/Analysis/build_count_table.py {params.dereps} --table {output.tbl} --anno {output.anno} 2> {log}
+
+### deseq2_DE.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.cnt} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}
+
+### deseq2_DE.smk
+set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}
+
+### deseq2_DE.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEENV} --loglevel DEBUG 2>> {log}
+
+### dexseq_DEU.smk
+{params.bins}/Analysis/DEU/prepare_deu_annotation.py -f {output.countgtf} {params.countstrand} <(gzip -cdfq {input.anno}) {output.deugtf} 2>> {log}
+
+### dexseq_DEU.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {input.countgtf}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k2,2 -k3,3n -k4,4n -k1,1 -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### dexseq_DEU.smk
+{params.bins}/Analysis/build_count_table.py {params.dereps} --table {output.tbl} --anno {output.anno} 2> {log}
+
+### dexseq_DEU.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.cnt} {params.ref} {input.flat} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.deupara}\' 2> {log}
+
+### dexseq_DEU.smk
+set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] <= -{params.lfc_cut} ||$F[9] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}
+
+### dexseq_DEU.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEUENV} --loglevel DEBUG 2>> {log}
+
+### dexseq_DTU.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}
+
+### dexseq_DTU.smk
+set +o pipefail; for i in {input};do fn=\"${{i##*/}}\"; if [[ -s \"$i\" ]]; then zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane ' next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/SigUP_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn; else touch DTU/{combo}/Sig_$fn DTU/{combo}/SigUP_$fn DTU/{combo}/SigDOWN_$fn; fi; done 2> {log}
+
+### dexseq_DTU.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}
+
+### diego_DAS.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### diego_DAS.smk
+echo \'{params.slist}\' 1> {output.smap} 2>> {log} && echo \'{params.clist}\' 1> {output.cmap} 2>> {log}
+
+### diego_DAS.smk
+{params.bins}/Analysis/DAS/FeatureCounts2DIEGO.py {params.dereps} --table {output.tbl} --anno {output.anno} 2> {log}
+
+### diego_DAS.smk
+python3 {params.bins}/Analysis/DAS/diego_contrast_files.py -a <(zcat {input.anno}) -b {params.pcombo} -c {params.compare} -o {params.outdir} 2> {log}
+
+### diego_DAS.smk
+set +euo pipefail; arr=({input.contrast}); orr=({params.outfile}); orrt=({log}); for i in ${{!arr[@]}}; do basecond=$(head -n 1 ${{arr[$i]}} | awk \'{{print $1}}\'); {params.bins} -a <(zcat {input.tbl}) -b ${{arr[$i]}} -x $basecond -e -f ${{orr[$i]}} &> ${{orrt[$i]}};done && arr=({input.contrast}); orr=({output.csv}); orrt=({log}); for i in ${{!arr[@]}}; do basecond=$(head -n 1 ${{arr[$i]}} | awk \'{{print $1}}\'); {params.bins} -a <(zcat {input.tbl}) -b ${{arr[$i]}} -x $basecond {params.dpara} 1> ${{orr[$i]}} 2>> ${{orrt[$i]}};done
+
+### diego_DAS.smk
+set +o pipefail; arr=({input.csv}); orr=({output.sig}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then cat $a|head -n1 > \"${{orr[$i]}}\"; cat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[10]);if ($F[10] eq \"yes\") {{print}}' >> \"${{orr[$i]}}\" &>> {log}; else touch \"${{orr[$i]}}\"; fi; done
+
+### diego_DAS.smk
+for pdfile in {input} ; do convert -verbose -density 500 -resize '800' $pdfile ${{pdfile%pdf}}png; done
+
+### diego_DAS.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DASENV} --loglevel DEBUG 2>> {log}
+
+### dorado.smk
+{params.caller} download --directory {params.p5dir} --model {params.cmodel} &> {log} && {params.caller} basecaller {params.cpara} {params.p5dir}/{params.cmodel} {params.p5dir}/ 2>> {log} 1> {output.bam} && samtools view -h {output.bam}|samtools fastq -n - | pigz > {output.fq}
+
+### drimseq_DTU.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}
+
+### drimseq_DTU.smk
+set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}
+
+### drimseq_DTU.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}
+
+### dtu_base.smk
+set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### dtu_base.smk
+ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}
+
+### dtu_base.smk
+ln -s {params.filetolink} {output.r1}
+
+### dtu_base.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### dtu_base.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.index} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### dtu_base.smk
+terminus group {params.tpara} -d {input.ctsdir} -o {params.outdir} &> {log}
+
+### dtu_base.smk
+terminus collapse -d {input.dirs} -o {params.outdir} &> {log}; for d in {input.dirs}; do b=$(basename $d); gzip -c {params.outdir}/$b/quant.sf > {params.outdir}/$b/quant.sf.gz; done 2>> {log}
+
+### dtu_base.smk
+python3 {params.bins}/Analysis/build_DTU_table.py {params.dereps} --anno {output.anno} --loglevel DEBUG 2> {log}
+
+### edger_DAS.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(zcat {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### edger_DAS.smk
+{params.bins}/Analysis/build_count_table.py {params.dereps} --ids --table {output.tbl} --anno {output.anno} 2> {log}
+
+### edger_DAS.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.tbl} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.daspara}\' 2> {log} 
+
+### edger_DAS.smk
+set +o pipefail; arr=({input.sort}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] <= -{params.lfc_cut} ||$F[6] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}
+
+### edger_DAS.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DASENV} --loglevel DEBUG 2>> {log}
+
+### edger_DE.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### edger_DE.smk
+{params.bins}/Analysis/build_count_table.py {params.dereps} --table {output.tbl} --anno {output.anno} 2> {log}
+
+### edger_DE.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.tbl} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}
+
+### edger_DE.smk
+set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}
+
+### edger_DE.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEENV} --loglevel DEBUG 2>> {log}
+
+### edger_DEU.smk
+{params.countb} -T {threads} {params.cpara} {params.paired} {params.stranded} -a <(gzip -cdfq {params.anno}) -o {output.tmp} {input.reads} 2> {log} && head -n2 {output.tmp} |gzip > {output.tmph} && export LC_ALL=C; tail -n+3 {output.tmp}|sort --parallel={threads} -S {params.sortmem}G -T TMP -k1,1 -k2,2n -k3,3n -u |gzip >> {output.tmpc} && zcat {output.tmph} {output.tmpc} |gzip > {output.cts} && mv {output.tmp}.summary {output.cts}.summary
+
+### edger_DEU.smk
+{params.bins}/Analysis/build_count_table.py {params.dereps} --ids --table {output.tbl} --anno {output.anno} 2> {log}
+
+### edger_DEU.smk
+Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.tbl} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.deupara}\' 2> {log}
+
+### edger_DEU.smk
+set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}
+
+### edger_DEU.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEUENV} --loglevel DEBUG 2>> {log}
+
+### fastp.smk
+{params.trim} --thread {threads} --in1 {input.r1} --in2 {input.r2} --out1 {output.o1} --out2 {output.o2} {params.tpara}
+
+### fastp.smk
+mv {input.o1} {output.r1} && mv {input.o2} {output.r2}
+
+### fastp.smk
+{params.trim} --thread {threads} -i {input.r1} -o {output.o1} {params.tpara}
+
+### fastp.smk
+mv {input.o1} {output.r1}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}
+
+### fastqc.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f bam {input.r1} 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_dedup_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}
+
+### fastqc_raw.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_raw.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fastqc_raw.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_raw.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.o1});fastqc --quiet -o $OUT -t {threads} --noextract {params.qpara} -f fastq {input.r1} 2> {log}
+
+### fastqc_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### fgumi.smk
+mkdir -p {output.td} && {params.dedup} extract {params.epara} --inputs {input.r1} {input.r2} --sample {params.sname} --library {params.sname} --output {output.ubam} > {log} 2>&1 && samtools fastq -n -1 {output.o1} -2 {output.o2} -0 /dev/null -s /dev/null {output.ubam} >> {log} 2>&1
+
+### fgumi.smk
+mkdir -p {output.td} && {params.dedup} extract {params.epara} --inputs {input.r1} --sample {params.sname} --library {params.sname} --output {output.ubam} > {log} 2>&1 && samtools fastq -n {output.ubam} | gzip -c > {output.o1} && echo done >> {log}
+
+### fgumi.smk
+
+
+### fgumi.smk
+
+
+### fgumi_dedup.smk
+mkdir -p {output.td} && {params.dedup} dedup {params.dpara} --input {input.bam} --output {output.bam} 2> {log} && samtools index {output.bam} 2>> {log}
+
+### guppy.smk
+ echo \"{params.f5file}\" > {params.f5dir}/f5list && {params.caller} {params.cpara} -c {params.cmodel} --compress_fastq -i {params.f5dir} --input_file_list {params.f5dir}/f5list -s {params.f5dir}/BASECALL 2> {log} && cat {params.f5dir}/BASECALL/pass/fastq_runid_*.fastq.gz > {output.fq} && rm -f {params.f5dir}/BASECALL/pass/fastq_runid_*.fastq.gz && cat {params.f5dir}/BASECALL/*.log >> {log} && rm -f {params.f5dir}/BASECALL/*.log && mv -f {params.f5dir}/BASECALL/sequencing_summary.txt {output.summary} &&  mv -f {params.f5dir}/BASECALL/sequencing_telemetry.js {output.telemetry} && rm -f {params.f5dir}/f5list
+
+### hisat2.smk
+if [[ -f \"{output.idxfile}\" ]]; then ln -fs {params.lnkidx} {output.idx} && mkdir -p {output.uidx} && touch {output.tmp} {output.idxfile} && echo \"Found hisat index, continue with mapping\" ; else zcat {input.fa} > {output.tmp} && mkdir -p {output.uidx} ;{params.indexer}-build {params.ipara} -p {threads} {output.tmp} {output.uidx}/{params.pref} 2> {log} && ln -fs {params.lnkidx} {output.idx} && touch {output.uidx} && touch {output.idxfile};fi
+
+### hisat2.smk
+set +euo pipefail; {params.mapp} {params.mpara} {params.stranded} -p {threads} -x {input.uidx}/{params.pref} -1 {input.r1} -2 {input.r2} --new-summary --summary-file {output.summary} --un-conc-gz {params.umn}.unmapped -S {params.muz} &> {log} && gzip {params.muz} && touch {params.umn}.unmapped.1.gz {params.umn}.unmapped.2.gz; rename 's/.unmapped.([1|2]).gz/_R$1_unmapped.fastq.gz/' {params.umn}.unmapped.*.gz; touch {output.unmapped_r1} {output.unmapped_r2} &>> {log}
+
+### hisat2.smk
+set +euo pipefail; {params.mapp} {params.mpara} {params.stranded} -p {threads} -x {input.uidx}/{params.pref} -U {input.query} --new-summary --summary-file {output.summary} --un-gz {output.unmapped} -S {params.muz} &> {log} && gzip {params.muz} && touch {output.unmapped}
+
+### kallisto.smk
+set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -t {threads} -i {output.uidx} {input.fa} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### kallisto.smk
+set +euo pipefail; {params.mapp} quant -t {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} {input.r1} {input.r2} &>> {log} && gzip {output.ctsdir}/abundance.tsv && ln -fs {params.linksf}/abundance.tsv.gz {output.cnts} &>> {log}
+
+### kallisto.smk
+set +euo pipefail; {params.mapp} quant -t {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} --single {input.r1} &>> {log} && gzip {output.ctsdir}/abundance.tsv && ln -fs {params.linksf}/abundance.tsv.gz {output.cnts} &>> {log}
+
+### kallisto_trim.smk
+ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}
+
+### kallisto_trim.smk
+ln -s {params.filetolink} {output.r1}
+
+### kallisto_trim.smk
+set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -t {threads} -i {output.uidx} {input.fa} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### kallisto_trim.smk
+set +euo pipefail; {params.mapp} quant -t {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} {input.r1} {input.r2} &>> {log} && gzip {output.ctsdir}/abundance.tsv && ln -fs {params.linksf}/abundance.tsv.gz {output.cnts} &>> {log}
+
+### kallisto_trim.smk
+set +euo pipefail; {params.mapp} quant -t {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} --single {input.r1} &>> {log} && gzip {output.ctsdir}/abundance.tsv && ln -fs {params.linksf}/abundance.tsv.gz {output.cnts} &>> {log}
+
+### macs2.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(samtools view {input.bam} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then {params.peak} callpeak -t {input.bam} {params.pairing} --outdir {params.outdir} -n {params.outname} -f {params.mapmode} {params.ppara} 2> {log} && gzip {params.outdir}/{params.outname}_peaks.narrowPeak 2>> {log} && ln -s {params.outname}_peaks.narrowPeak.gz {output.peak} 2>> {log}; else gzip < /dev/null > {output.peak}; echo \"File {input.bam} empty\" >> {log}; fi
+
+### macs2.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pk} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.pk} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.pt} && bedtools getfasta -fi {input.fa} -bed {output.pt} -name -tab -s -fullHeader -fo {output.ps} && cut -d$'\t' -f2 {output.ps}|paste -d$'\t' <(zcat {input.pk}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip  > {output.peak} 2> {log}; else gzip < /dev/null > {output.peak} && touch {output.pt} {output.ps}; fi
+
+### macs2.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b {input} -a {params.anno} |gzip > {output} 2> {log}
+
+### macs2.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### macs2.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### macs2.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw}) | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re}) | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### macs2.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.fw} > {output.tfw} && bedGraphToBigWig {output.tfw} {input.sizes} {output.fw} 2> {log}; else touch {output.tfw}; gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.re} > {output.tre} && bedGraphToBigWig {output.tre} {input.sizes} {output.re} 2>> {log}; else touch {output.tre}; gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### macs2.smk
+echo -e \"{input.fw}\\n{input.re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}.trackdone && touch {input.re}.trackdone 2> {log}
+
+### macs3.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(samtools view {input.bam} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then {params.peak} callpeak -t {input.bam} {params.pairing} --outdir {params.outdir} -n {params.outname} -f {params.mapmode} {params.ppara} 2> {log} && gzip {params.outdir}/{params.outname}_peaks.narrowPeak 2>> {log} && ln -s {params.outname}_peaks.narrowPeak.gz {output.peak} 2>> {log}; else gzip < /dev/null > {output.peak}; echo \"File {input.bam} empty\" >> {log}; fi
+
+### macs3.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pk} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.pk} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.pt} && bedtools getfasta -fi {input.fa} -bed {output.pt} -name -tab -s -fullHeader -fo {output.ps} && cut -d$'\t' -f2 {output.ps}|paste -d$'\t' <(zcat {input.pk}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip  > {output.peak} 2> {log}; else gzip < /dev/null > {output.peak} && touch {output.pt} {output.ps}; fi
+
+### macs3.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b {input} -a {params.anno} |gzip > {output} 2> {log}
+
+### macs3.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### macs3.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### macs3.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw}) | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re}) | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### macs3.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.fw} > {output.tfw} && bedGraphToBigWig {output.tfw} {input.sizes} {output.fw} 2> {log}; else touch {output.tfw}; gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.re} > {output.tre} && bedGraphToBigWig {output.tre} {input.sizes} {output.re} 2>> {log}; else touch {output.tre}; gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### macs3.smk
+echo -e \"{input.fw}\\n{input.re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}.trackdone && touch {input.re}.trackdone 2> {log}
+
+### manipulate_genome.smk
+set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### manipulate_genome.smk
+set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1);chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### manipulate_genome.smk
+set +o pipefail; gzip -cdfq {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### manipulate_genome.smk
+set +o pipefail; zcat {input[0]} |perl -F\\\\040 -wane 'if($_ =~ /^>/){{$F[0] = $F[0] =~ /^>chr/ ? $F[0] : \">chr\".substr($F[0],1))=~ s/\_/\./g;chomp($F[0]);print \"\\n\".$F[0].\"\\n\"}} else{{($line=$_)=~s/\\r[\\n]*/\\n/gm; chomp($line=$_); print $line}}' |tail -n+2 > {output.fa} && {params.bins}/Preprocessing/indexfa.sh {output.fa} 2> {log} && cut -f1,2 {output.fai} > {output.fas}
+
+### mapping.smk
+set +o pipefail; export LC_ALL=C; samtools view -H {input.mapps}|grep '^@HD' |pigz -p 1 -f > {output.tmphead} 2> {log}; samtools view -H {input.mapps}|grep '^@SQ'|sort -t$'\t' -k1,1 -k2,2V |pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep '^@RG'|pigz -p 1 -f >> {output.tmphead} 2>> {log}; samtools view -H {input.mapps}|grep -P '^@PG'|pigz -p {threads} -f >> {output.tmphead} 2>> {log}; samtools view -h {input.mapps} | grep -v \"^@\"|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k3,3V -k4,4n - |pigz -p {threads} -f > {output.tmpfile} 2>> {log}; cat {output.tmphead} {output.tmpfile} > {output.sortedsam} 2>> {log}
+
+### mapping.smk
+zcat {input.sortedsam} | samtools view -bS - > {output.bam} && samtools index {output.bam} 2> {log}
+
+### mapping.smk
+{params.bins}/Shells/UniqueSam_woPicard.sh {input.sortedsam} {output.uniqsam} {threads} 2> {log}
+
+### mapping.smk
+zcat {input.uniqsam} | samtools view -bS - > {output.uniqbam} && samtools index {output.uniqbam} 2> {log}
+
+### minimap.smk
+{params.indexer} -t {threads} -d {output.uidx} {params.ipara} {input.fa} 2> {log} && ln -s {params.linkidx} {output.idx}
+
+### minimap.smk
+{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.q1} {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### minimap.smk
+{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc_rustqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multiqc_rustqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### multx.smk
+{params.multx} -B {input.whitelist} -b <(zcat {input.r1}) <(zcat {input.r2}) -o %_R1_demux.fastq.gz -o %_R2_demux.fastq.gz {params.tpara} 2>&1 > {log} 
+
+### multx.smk
+fastp --in1 {input.r1} --out1 {output.r1_trimmed} --trim_front1 1 --disable_adapter_trimming --disable_quality_filtering --disable_trim_poly_g --disable_length_filtering --dont_eval_duplication --thread {threads}
+
+### multx.smk
+{params.multx}  -B {input.whitelist} -b <(zcat {input.r1}) <(zcat {input.r2}) -o %_R1_demux.fastq.gz -o %_R2_demux.fastq.gz {params.tpara} 2>&1 > {log} > {log} 2>&1
+
+### multx.smk
+cat {input.o1_first} {input.o1_second} > {output.o1} && cat {input.o2_first} {input.o2_second} > {output.o2}
+
+### oarfish.smk
+set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {input.anno} --genome-fasta {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### peaks.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### peaks.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### peaks.smk
+{params.bins}/Universal/ExtendBed.pl -u 1 -b {input.pks} -o {output.ext} -g {input.ref} 2> {log}
+
+### peaks.smk
+{params.bins}/Universal/ExtendBed.pl -d 1 -b {input.pks} -o {output.ext} -g {input.ref}  2> {log}
+
+### peaks.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### peaks.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### peaks.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### peaks.smk
+perl {params.bins}/Analysis/PreprocessPeaks.pl -p <(zcat {input.bedg}) {params.opts} |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6 | gzip > {output.pre} 2> {log}
+
+### peaks.smk
+perl {params.bins}/Analysis/FindPeaks.pl {params.opts} -p <(zcat {input.pre}) 2> {log}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.peak} 2>> {log}
+
+### peaks.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pk} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then export LC_ALL=C; zcat {input.pk} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.pt} && bedtools getfasta -fi {input.fa} -bed {output.pt} -name -tab -s -fullHeader -fo {output.ps} && cut -d$'\t' -f2 {output.ps}|paste -d$'\t' <(zcat {input.pk}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip  > {output.peak} 2> {log}; else gzip < /dev/null > {output.peak} && touch {output.pt} {output.ps}; fi
+
+### peaks.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b <(zcat {input}) -a {params.anno} |gzip > {output} 2> {log}
+
+### peaks.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f <(zcat {input.pk}) -c {input.sizes} -p peak -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### peaks.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f <(zcat {input.pk}) -c {input.sizes} -p peak -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### peaks.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### peaks.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.fw} > {output.tfw} && bedGraphToBigWig {output.tfw} {input.sizes} {output.fw} 2> {log}; else touch {output.tfw}; gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.re} > {output.tre} && bedGraphToBigWig {output.tre} {input.sizes} {output.re} 2>> {log}; else touch {output.tre}; gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### peaks.smk
+echo -e \"{input.fw}\\n{input.re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}\.trackdone && touch {input.re}.trackdone 2> {log}
+
+### picard_dedup.smk
+mkdir -p {output.td} && {params.dedup} {params.jpara} MarkDuplicates --REMOVE_DUPLICATES true --ASSUME_SORT_ORDER coordinate --TMP_DIR {output.td} --INPUT {input.bam} --OUTPUT {output.bam} --METRICS_FILE {output.met} {params.dpara} 2> {log} && samtools index {output.bam} 2>> {log} && cp -f {output.met} $(dirname {log})/
+
+### piranha.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### piranha.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### piranha.smk
+{params.bins}/Universal/ExtendBed.pl -u 1 -b {input.pks} -o {output.ext} -g {input.ref} 2> {log}
+
+### piranha.smk
+{params.bins}/Universal/ExtendBed.pl -d 1 -b {input.pks} -o {output.ext} -g {input.ref}  2> {log}
+
+### piranha.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### piranha.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### piranha.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' >> {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat} 2>> {log}
+
+### piranha.smk
+perl {params.bins}/Analysis/PreprocessPeaks.pl -p <(zcat {input.bedg}) {params.opts} | sort -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6| gzip > {output.pre} 2> {log}
+
+### piranha.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pre} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then {params.peak} {params.ppara} <(zcat {input.pre}|sort -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6) 2> {log}|tail -n+2| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |grep -v 'nan'| gzip > {output.peak} 2>> {log}; else gzip < /dev/null > {output.peak}; echo \"File {input.pre} empty\" >> {log}; fi
+
+### piranha.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pk} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then export LC_ALL=C; zcat {input.pk} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.pt} && bedtools getfasta -fi {input.fa} -bed {output.pt} -name -tab -s -fullHeader -fo {output.ps} && cut -d$'\t' -f2 {output.ps}|sed 's/t/u/ig'|paste -d$'\t' <(zcat {input.pk}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip  > {output.peak} 2> {log}; else gzip < /dev/null > {output.peak} && touch {output.pt} {output.ps}; fi
+
+### piranha.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b <(zcat {input}) -a {params.anno} |gzip > {output} 2> {log}
+
+### piranha.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### piranha.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### piranha.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### piranha.smk
+zcat {input.fw} > {output.tfw} 2>> {log} && bedGraphToBigWig {output.tfw} {input.fas} {output.fw} 2>> {log} && zcat {input.re} > {output.tre} 2>> {log} && bedGraphToBigWig {output.tre} {input.fas} {output.re} 2>> {log}
+
+### piranha.smk
+echo -e \"{input.fw}\\n{input.re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}.trackdone && touch {input.re}.trackdone 2> {log}
+
+### piscem.smk
+if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found index, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && mkdir -p {output.uidx} && {params.indexer} build -t {threads} {params.ipara} -s {output.tmpfa} -o {output.uidx}/{params.pref} &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx};fi
+
+### piscem.smk
+{params.mapp} map-sc -t {threads} {params.mpara} -i {params.idxpref} -1 {input.r1} -2 {input.r2} -o {output.rad} &> {log}
+
+### premultiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.condition}; if [ -d QC/{wildcards.condition} ]; then SCAN=\"$SCAN QC/{wildcards.condition}\"; fi; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### premultiqc.smk
+OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.condition}; if [ -d QC/{wildcards.condition} ]; then SCAN=\"$SCAN QC/{wildcards.condition}\"; fi; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/
+
+### rammap.smk
+gzip -cdfq {input.fa} > {output.tmpfa} && {params.indexer} -t {threads} -d {output.uidx} {params.ipara} {output.tmpfa} 2> {log} && ln -s {params.linkidx} {output.idx}
+
+### rammap.smk
+{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.q1} {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### rammap.smk
+{params.mapp} -t {threads} {params.mpara} {input.uidx} {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_dedup_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -o $OUT $SCAN 2> {log}
+
+### rastqc_raw.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_raw.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rastqc_raw.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_raw.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rastqc_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rastqc_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_trim.smk
+OUT=$(dirname {output.o1});rastqc --quiet --extract -o $OUT -t {threads} {params.qpara} {input.r1} 2> {log}; FILE=$(basename {input.r1}); BASE=${{FILE%.gz}}; BASE=${{BASE%.*}}_fastqc; sed -i -E '/^>>.*\t(PASS|WARN|FAIL)$/ s/\tPASS$/\tpass/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tWARN$/\twarn/; /^>>.*\t(PASS|WARN|FAIL)$/ s/\tFAIL$/\tfail/' \"$OUT/$BASE/fastqc_data.txt\"; rm \"$OUT/$BASE.zip\"; (cd \"$OUT\" && python -m zipfile -c \"$BASE.zip\" \"$BASE\")
+
+### rastqc_trim.smk
+OUT=$(dirname {output.html}); SCAN=QC/{wildcards.combo}/{wildcards.condition}; mkdir -p $OUT; export LC_ALL=C.UTF-8; multiqc -f {params.qpara} --exclude picard --exclude gatk -k json -z -s -o $OUT $SCAN 2> {log}
+
+### rustar.smk
+if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir TMP/rustar_generate_index --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf TMP/rustar_generate_index
+
+### rustar.smk
+{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} 
+
+### rustar.smk
+{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}
+
+### rustar.smk
+{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} 
+
+### rustqc.smk
+gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}
+
+### rustqc.smk
+gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}
+
+### salmon.smk
+set +euo pipefail; {params.mapp} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### salmon.smk
+set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} quant -p {threads} -t {input.fa} -a {params.nbam} --deterministic {params.cpara} -o {output.ctsdir} &>> {log} && rm -f {params.nbam} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmon.smk
+set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} quant -p {threads} -a {params.nbam} --annotation {input.anno} --genome {input.fa} {params.cpara} -o {output.ctsdir} &>> {log} && rm -f {params.nbam} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmon.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmon.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmon_trim.smk
+ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}
+
+### salmon_trim.smk
+ln -s {params.filetolink} {output.r1}
+
+### salmon_trim.smk
+set +euo pipefail; {params.mapp} index {params.ipara} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### salmon_trim.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} -1 {input.r1} -2 {input.r2} &>> {log} && gzip {output.ctsdir}/quant.sf && ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmon_trim.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.cpara} -o {output.ctsdir} -r {input.r1} &>> {log} && gzip {output.ctsdir}/quant.sf ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}
+
+### salmonalign.smk
+set +euo pipefail; {params.indexer} index {params.ipara} {params.decoy} -p {threads} -t {input.fa} -i {output.uidx} &>> {log} && ln -fs {params.linkidx} {output.idx}
+
+### salmonalign.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings=/dev/stdout -o {params.outdir} -1 {input.q1} -2 {input.q2} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### salmonalign.smk
+set +euo pipefail; {params.mapp} quant -p {threads} -i {input.uidx} {params.stranded} {params.mpara} --writeMappings=/dev/stdout -o {params.outdir} -r {input.query} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### scyphy.smk
+python {params.bins}/Analysis/RemoveSoftClip.py -f {input.fa} -b {input.bam} {params.opts} -o \'-\' | samtools sort -T {params.tmpidx}/SAMSORT -o {output.bam} --threads {threads} \'-\' 2>> {log} && samtools index {output.bam} 2>> {log} && rm -rf TMP/{params.tmpidx}
+
+### scyphy.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### scyphy.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### scyphy.smk
+{params.bins}/Universal/ExtendBed.pl -u 0 -b {input.pks} -o {output.ext} -g {input.ref} 2> {log}
+
+### scyphy.smk
+{params.bins}/Universal/ExtendBed.pl -d 0 -b {input.pks} -o {output.ext} -g {input.ref}  2> {log}
+
+### scyphy.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_fw} 2>> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' > {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_re} 2>> {log} && zcat {output.concat_fw} {output.concat_re} | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat}
+
+### scyphy.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_fw} 2>> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' > {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_re} 2>> {log} && zcat {output.concat_fw} {output.concat_re} | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat}
+
+### scyphy.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"+\")' > {output.tosrt} 2> {log} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_fw} 2>> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |perl -wlane 'print join(\"\t\",@F[0..2],\".\",$F[3],\"-\")' > {output.tosrt} && cat {output.tosrt}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat_re} 2>> {log} && zcat {output.concat_fw} {output.concat_re} | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.concat}
+
+### scyphy.smk
+perl {params.bins}/Analysis/PreprocessPeaks.pl -p <(zcat {input.bedg}) {params.opts} | sort -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6 | gzip > {output.pre} 2> {log}
+
+### scyphy.smk
+perl {params.bins}/Analysis/PreprocessPeaks.pl -p <(zcat {input.bedg}) {params.opts} | sort -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6 | gzip > {output.pre} 2> {log}
+
+### scyphy.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pre} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then {params.peak} {params.ppara} <(zcat {input.pre}|sort -t$'\t' -k1,1 -k3,3n -k2,2n -k6,6) 2> {log}|tail -n+2| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |grep -v 'nan'| gzip > {output.peak} 2>> {log}; else gzip < /dev/null > {output.peak}; echo \"File {input.pre} empty\" >> {log}; fi
+
+### scyphy.smk
+perl {params.bins}/Analysis/FindPeaks.pl {params.opts} -p <(zcat {input.pre}) 2> {log}| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.peak} 2>> {log}
+
+### scyphy.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.pk} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.pk} | perl -wlane '$F[0] = $F[0] =~ /^chr/ ? $F[0] : \"chr\".$F[0]; print join(\"\\t\",@F[0..5])' > {output.pt} && bedtools getfasta -fi {input.fa} -bed {output.pt} -name -tab -s -fullHeader -fo {output.ps} && cut -d$'\t' -f2 {output.ps}|sed 's/t/u/ig'|paste -d$'\t' <(zcat {input.pk}) - |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip  > {output.peak} 2> {log}; else gzip < /dev/null > {output.peak} && touch {output.pt} {output.ps}; fi
+
+### scyphy.smk
+perl {params.bins}/Universal/AnnotateBed.pl -b <(zcat {input}) -a {params.anno} |gzip > {output} 2> {log}
+
+### scyphy.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### scyphy.smk
+perl {params.bins}/Universal/Bed2Bedgraph.pl -f {input.pk} -c {input.sizes} -p score -x {output.tfw} -y {output.tre} -a track 2>> {log} && zcat {output.tfw}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n  |gzip > {output.fw} 2>> {log} &&  zcat {output.tre}|sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### scyphy.smk
+set +o pipefail; export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_fw} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_fw}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_fw})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_fw} 2> {log}; else gzip < /dev/null > {output.map_fw}; echo \"File {input.map_fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_re} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_re}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_re})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_re} 2> {log}; else gzip < /dev/null > {output.map_re}; echo \"File {input.map_re} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_fw_ext} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_fw_ext}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_fw_ext})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_fw_ext} 2> {log}; else gzip < /dev/null > {output.map_fw_ext}; echo \"File {input.map_fw_ext} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_re_ext} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_re_ext}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_re_ext})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_re_ext} 2> {log}; else gzip < /dev/null > {output.map_re_ext}; echo \"File {input.map_re_ext} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_fw_rev} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_fw_rev}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_fw_rev})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_fw_rev} 2> {log}; else gzip < /dev/null > {output.map_fw_rev}; echo \"File {input.map_fw_rev} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.map_re_rev} | head -c 1 | tr \'\\0\\n\' __)\" ]]; then scale=$(bc <<< \"scale=6;$(zcat {input.map_re_rev}|cut -f5|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..2]),\"\t\",$F[4]/$sc' <(zcat {input.map_re_rev})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.map_re_rev} 2> {log}; else gzip < /dev/null > {output.map_re_rev}; echo \"File {input.map_re_rev} empty\" >> {log}; fi
+
+### scyphy.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.fw} > {output.tfw} 2>> {log} && bedGraphToBigWig {output.tfw} {input.fas} {output.fw} 2>> {log}; else touch {output.tfw}; gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.re} > {output.tre} 2>> {log} && bedGraphToBigWig {output.tre} {input.fas} {output.re} 2>> {log}; else touch {output.tre}; gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi && zcat {input.map_fw} > {output.tmapfw} 2>> {log} && bedGraphToBigWig {output.tmapfw} {input.fas} {output.map_fw} 2>> {log} && zcat {input.map_re} > {output.tmapre} 2>> {log} && bedGraphToBigWig {output.tmapre} {input.fas} {output.map_re} 2>> {log} && zcat {input.map_fw_ext} > {output.tmapfw_ext} 2>> {log} && bedGraphToBigWig {output.tmapfw_ext} {input.fas} {output.map_fw_ext} 2>> {log} && zcat {input.map_re_ext} > {output.tmapre_ext} 2>> {log} && bedGraphToBigWig {output.tmapre_ext} {input.fas} {output.map_re_ext} 2>> {log} && zcat {input.map_fw_rev} > {output.tmapfw_rev} 2>> {log} && bedGraphToBigWig {output.tmapfw_rev} {input.fas} {output.map_fw_rev} 2>> {log} && zcat {input.map_re_rev} > {output.tmapre_rev} 2>> {log} && bedGraphToBigWig {output.tmapre_rev} {input.fas} {output.map_re_rev} 2>> {log}
+
+### scyphy.smk
+echo -e \"{input.fw}\\n{input.re}\\n{input.map_fw}\\n{input.map_re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}.trackdone && touch {input.re}.trackdone && touch {input.map_fw}.trackdone && touch {input.map_re}.trackdone 2> {log} && touch {input.map_fw_ext}.trackdone && touch {input.map_re_ext}.trackdone 2> {log} && touch {input.map_fw_rev}.trackdone && touch {input.map_re_rev}.trackdone 2> {log}
+
+### segemehl.smk
+{params.indexer} --threads {threads} {params.ipara} -d {input.fa} -x {output.uidx} &> {log} && ln -fs {params.linkidx} {output.idx}
+
+### segemehl.smk
+{params.mapp} {params.mpara} -d {input.fa} -i {input.uidx} -q {input.r1} -p {input.r2} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### segemehl.smk
+{params.mapp} {params.mpara} -d {input.fa} -i {input.uidx} -q {input.query} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### segemehl3.smk
+{params.indexer} --threads {threads} {params.ipara} -d {input.fa} -x {output.uidx} &> {log} && ln -fs {params.linkidx} {output.idx}
+
+### segemehl3.smk
+set +o pipefail; {params.mapp} {params.mpara} -d {input.ref} -i {input.uidx} -q {input.r1} -p {input.r2} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2} && touch {output.txt} {output.sngl} {output.mult} {params.split}
+
+### segemehl3.smk
+set +o pipefail; {params.mapp} {params.mpara} -d {input.ref} -i {input.uidx} -q {input.query} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped} && touch {output.txt} {output.sngl} {output.mult} {params.split}
+
+### segemehl3_bisulfite.smk
+{params.indexer} --threads {threads} {params.ipara} -d {input.fa} -x {output.uidx1} -y {output.uidx2} &> {log} && ln -fs {params.linkidx1} {output.idx1} && ln -fs {params.linkidx2} {output.idx2}
+
+### segemehl3_bisulfite.smk
+set +o pipefail;{params.mapp} {params.mpara} -d {input.fa} -i {input.uidx1} -j {input.uidx2} -q {input.r1} -p {input.r2} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### segemehl3_bisulfite.smk
+set +o pipefail; {params.mapp} {params.mpara} -d {input.fa} -i {input.uidx1} -j {input.uidx2} -q {input.query} --threads {threads} 2> {log}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n --verbosity 0 - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### segemehl_bisulfite.smk
+{params.indexer} --threads {threads} {params.ipara} -d {input.fa} -x {output.uidx1} -y {output.uidx2} &> {log} && ln -fs {params.linkidx1} {output.idx1} && ln -fs {params.linkidx2} {output.idx2}
+
+### segemehl_bisulfite.smk
+{params.mapp} {params.mpara} -d {input.fa} -i {input.uidx1} -j {input.uidx2} -q {input.r1} -p {input.r2} --threads {threads} -o {output.tmpmap} 2> {log} && cat {output.tmpmap}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools collate -u -O -|samtools fastq -n -c 6 -1 {output.unmapped1} -2 {output.unmapped2} - ) 2>> {log} &>/dev/null && touch {output.unmapped1} {output.unmapped2}
+
+### segemehl_bisulfite.smk
+{params.mapp} {params.mpara} -d {input.fa} -i {input.uidx1} -j {input.uidx2} -q {input.query} --threads {threads} -o {output.tmpmap} 2> {log} && cat {output.tmpmap}| tee >(samtools view -h -F 4 |gzip > {output.mapped}) >(samtools view -h -f 4 |samtools fastq -n - | pigz > {output.unmapped}) 2>> {log} &>/dev/null && touch {output.unmapped}
+
+### simpleaf.smk
+if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && echo \"Found index, continue with quant\" ; else export ALEVIN_FRY_HOME={params.afhome}; mkdir -p {params.afhome}; {params.mapp} set-paths &>> {log}; zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && {params.mapp} index --fasta {output.tmpfa} --gtf {output.tmpanno} -t {threads} {params.ipara} -o {output.idx} &> {log};fi
+
+### simpleaf.smk
+export ALEVIN_FRY_HOME={params.afhome}; mkdir -p {output.ctsdir}; {params.mapp} quant --index {input.idx}/index --reads1 {input.r1} --reads2 {input.r2} -t {threads} {params.cpara} -o {params.quantdir} &> {log} && gzip -c {params.quantdir}/alevin/quants_mat.mtx > {output.cnts} 2>> {log}
+
+### simulatetrim.smk
+ln -s {params.filetolink} {output.r1} && ln -s {params.filetolink2} {output.r2}
+
+### simulatetrim.smk
+ln -s {params.filetolink} {output.r1}
+
+### spit_DTU.smk
+python3 {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}
+
+### spit_DTU.smk
+set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}
+
+### spit_DTU.smk
+python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DTUENV} --loglevel DEBUG 2>> {log}
+
+### sra.smk
+export NCBI_SETTINGS=\"{params.fpara}\"; prefetch {params.ids} -o {output.prefetch} &> {log}
+
+### sra.smk
+set +euo pipefail; export NCBI_SETTINGS=\"{params.fpara}\"; fasterq-dump -O {params.outdir[0]} -e {threads} -t TMP {params.spara} --split-files {params.ids} &> {params.wd}{log} ; cd {params.outdir[0]} ; rename 's/(.sra)*_([1|2])/_R$2/' {params.sra}*.fastq &>> {params.wd}{log} ; for i in {params.sra}*.fastq;do gzip $i &>> {params.wd}{log};done ; exit 0
+
+### sra.smk
+export NCBI_SETTINGS=\"{params.fpara}\"; prefetch {params.ids} -o {output.prefetch} &> {log}
+
+### sra.smk
+set +euo pipefail; export NCBI_SETTINGS=\"{params.fpara}\"; fasterq-dump -O {params.outdir[0]} -e {threads} -t TMP {params.spara} {params.ids} &> {params.wd}{log} ; cd {params.outdir[0]} ; rename 's/(.sra)*_([1|2])/_R$2/' {params.sra}*.fastq &>> {params.wd}{log} ; for i in {params.sra}*.fastq; do gzip $i &>> {params.wd}{log};done ; exit 0
+
+### star.smk
+if [[ -f \"{output.idxfile}\" ]]; then touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && echo \"Found SAindex, continue with mapping\" ; else zcat {input.fa} > {output.tmpfa} && zcat {params.anno} > {output.tmpref} && mkdir -p {output.uidx} && rm -rf {params.stmp} && {params.mapp} {params.ipara} --runThreadN {threads} --runMode genomeGenerate --outFileNamePrefix {output.uidx}/{params.pref} --outTmpDir {params.stmp} --genomeDir {output.uidx} --genomeFastaFiles {output.tmpfa}  &> {log} && touch {output.idxfile} && ln -fs {params.lnkidx} {output.idx} && cat {output.uidx}/*Log.out >> {log};fi && rm -rf {params.stmp}
+
+### star.smk
+{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} {input.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} && touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} 
+
+### star.smk
+{params.mapp} {params.mpara} --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {input.r1} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && gzip -c {output.tmp}.Aligned.out.sam > {output.mapped} && rm -f {output.tmp}.Aligned.out.sam 2>> {log} touch {output.tmp}.Unmapped.out.mate && gzip {output.tmp}.Unmapped.out.mate* && mv {output.tmp}.Unmapped.out.mate*.gz {output.unmapped} 2>> {log} && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>>{log} && touch {output.tmp}
+
+### star.smk
+{params.mapp} {params.mpara} {params.stranded} --outSAMattributes NH HI nM AS CR UR CB UB GX GN sS sQ sM --outSAMtype BAM SortedByCoordinate --runThreadN {threads} --genomeDir {input.uidx} --readFilesCommand zcat --readFilesIn {params.r1} {params.r2} --outFileNamePrefix {output.tmp}. --outReadsUnmapped Fastx &> {log} && samtools view -h {output.tmp}.Aligned.sortedByCoord.out.bam | gzip > {output.mapped} && rm -f {output.tmp}.Aligned.sortedByCoord.out.bam; touch {output.tmp}.Unmapped.out.mate1 {output.tmp}.Unmapped.out.mate2 && cat {output.tmp}.Unmapped.out.mate1 | paste - - - - |tr \"\\t\" \"\\n\" |gzip > {output.unmapped_r1} && cat {output.tmp}.Unmapped.out.mate2| paste - - - - |tr \"\\t\" \"\\n\"| gzip > {output.unmapped_r2} && rm -f {output.tmp}.Unmapped.out* && mv -f {output.tmp}*Log.out {output.log} && mv -f {output.tmp}*Log.final.out {output.log_final} && rm -f {output.tmp}*.Log.progress.out && mv {output.tmp}*.out* {params.tocopy} 2>> {log} && touch {output.tmp} 
+
+### starfusion.smk
+( zcat {input.fa} > {output.tmpfa} && zcat {input.anno} > {output.tmpanno} && mkdir -p {output.lib} && prep_genome_lib.pl --genome_fa {output.tmpfa} --gtf {output.tmpanno} --output_dir {output.lib} --CPU {threads} {params.bpara} ) &> {log}
+
+### starfusion.smk
+set +o pipefail; OUTDIR=$(dirname {output.preds}); if [[ -s \"{input.junction}\" ]]; then ctat_chr=$(grep -v '^#' {input.lib}/ref_annot.gtf 2>/dev/null | head -1 | cut -f1 | grep -c '^chr' || true); junc_chr=$(awk '!/^#/ && $1!=\"chr_donorA\"{{print $1; exit}}' {input.junction} | grep -c '^chr' || true); if [[ \"$ctat_chr\" == \"1\" && \"$junc_chr\" == \"0\" ]]; then echo \"Adding chr prefix to junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{if($1!~/^chr/)$1=\"chr\"$1; if($4!~/^chr/)$4=\"chr\"$4; if($1==\"chrMT\")$1=\"chrM\"; if($4==\"chrMT\")$4=\"chrM\"; print}}' {input.junction} > {output.normjunc}; elif [[ \"$ctat_chr\" == \"0\" && \"$junc_chr\" == \"1\" ]]; then echo \"Stripping chr prefix from junction to match CTAT lib\" >> {log}; awk 'BEGIN{{OFS=\"\\t\"}} /^#/{{print;next}} $1==\"chr_donorA\"{{print;next}} {{sub(/^chr/,\"\",$1); sub(/^chr/,\"\",$4); if($1==\"M\")$1=\"MT\"; if($4==\"M\")$4=\"MT\"; print}}' {input.junction} > {output.normjunc}; else cp {input.junction} {output.normjunc}; fi; {params.sf} --genome_lib_dir {input.lib} -J {output.normjunc} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; else mkdir -p $OUTDIR; touch {output.normjunc}; echo \"File {input.junction} empty, no chimeric STAR output found\" >> {log}; fi; touch {output.preds} {output.abridged}
+
+### starfusion.smk
+OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --right_fq {input.r2} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}
+
+### starfusion.smk
+OUTDIR=$(dirname {output.preds}); {params.sf} --genome_lib_dir {input.lib} --left_fq {input.r1} --output_dir $OUTDIR --CPU {threads} {params.fpara} &> {log}; touch {output.preds} {output.abridged}
+
+### summary.smk
+Rscript --vanilla -e \"rmarkdown::render('{input}',params=list(root='{params.currentpath}/'),output_file='{params.currentpath}/{params.outdir}/SUMMARY.html', quiet=TRUE)\" 2> {log}
+
+### trimgalore.smk
+{params.trim} --cores {threads} --paired --gzip {params.tpara} -o {params.odir} {input.r1} {input.r2} &> {log}
+
+### trimgalore.smk
+mv {input.o1} {output.r1} && mv {input.o2} {output.r2}
+
+### trimgalore.smk
+{params.trim} --cores {threads} --gzip {params.tpara} -o {params.odir} {input.r1} &> {log}
+
+### trimgalore.smk
+mv {input.o1} {output.r1}
+
+### ucsc.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/2$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### ucsc.smk
+bedtools bamtobed -split -i {input[0]} |sed 's/ /\_/g'|perl -wl -a -F\'\\t\' -n -e '$F[0] =~ s/\s/_/g;if($F[3]=~/\\/1$/){{if ($F[5] eq \"+\"){{$F[5] = \"-\"}}elsif($F[5] eq \"-\"){{$F[5] = \"+\"}}}} print join(\"\t\",@F[0..$#F])' |sort -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output[0]} 2> {log}
+
+### ucsc.smk
+export LC_ALL=C; export LC_COLLATE=C; bedtools genomecov -i {input.bed} -bg -split -strand + -g {input.sizes} | sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log} && bedtools genomecov -i {input.bed} -bg -split -strand - -g {input.sizes} |sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.re} 2>> {log}
+
+### ucsc.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.fw}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.fw})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n |gzip > {output.fw} 2> {log}; else gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then scale=$(bc <<< \"scale=6;$(zcat {input.re}|cut -f4|perl -wne '{{$x+=$_;}}END{{if ($x == 0){{$x=1}} print $x}}')/1000000\") perl -wlane '$sc=$ENV{{scale}};print join(\"\t\",@F[0..$#F-1]),\"\t\",$F[-1]/$sc' <(zcat {input.re})| sort --parallel={threads} -S {params.sortmem}G -T TMP -t$'\t' -k1,1 -k2,2n|gzip > {output.re} 2> {log}; else gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### ucsc.smk
+export LC_ALL=C; if [[ -n \"$(zcat {input.fw} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.fw} > {output.tfw} && bedGraphToBigWig {output.tfw} {input.sizes} {output.fw} 2> {log}; else touch {output.tfw}; gzip < /dev/null > {output.fw}; echo \"File {input.fw} empty\" >> {log}; fi && if [[ -n \"$(zcat {input.re} | head -c 1 | tr \'\\0\\n\' __)\" ]] ;then zcat {input.re} > {output.tre} && bedGraphToBigWig {output.tre} {input.sizes} {output.re} 2>> {log}; else touch {output.tre}; gzip < /dev/null > {output.re}; echo \"File {input.re} empty\" >> {log}; fi
+
+### ucsc.smk
+echo -e \"{input.fw}\\n{input.re}\"|python3 {params.bins}/Analysis/GenerateTrackDb.py -i {params.uid} -e 1 -f STDIN -u '' -g {params.gen} {params.options} && touch {input.fw}\.trackdone && touch {input.re}.trackdone 2> {log}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.wl}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.wl}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --stdout={output.o1}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.o1}
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} bam -i {input.bam} -o {output.td}/dedup.unsorted.bam --paired {params.dpara} > {log} 2>&1 && samtools sort -@ {threads} -o {output.bam} {output.td}/dedup.unsorted.bam >> {log} 2>&1 && samtools index {output.bam} >> {log} 2>&1
+
+### umicollapse.smk
+mkdir -p {output.td} && {params.dedup} bam -i {input.bam} -o {output.td}/dedup.unsorted.bam {params.dpara} > {log} 2>&1 && samtools sort -@ {threads} -o {output.bam} {output.td}/dedup.unsorted.bam >> {log} 2>&1 && samtools index {output.bam} >> {log} 2>&1
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.wl}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}
+
+### umitools.smk
+mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log} && ln -sf $(readlink -f {input.r2}) {output.o2} 2>> {log}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --read2-in={input.r2} --stdout={output.o1} --read2-out={output.o2}
+
+### umitools.smk
+mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log} && ln -sf $(readlink -f {input.r2}) {output.o2} 2>> {log}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} whitelist {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.wl}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --error-correct-cell --whitelist={input.wl} --stdin={input.r1} --stdout={output.o1}
+
+### umitools.smk
+mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} extract {params.dpara} --temp-dir {output.td} --log={log} --stdin={input.r1} --stdout={output.o1}
+
+### umitools.smk
+mkdir -p {output.td} && echo 'EXTRACT unset, linking input fastq(s) as-is' > {log} && ln -sf $(readlink -f {input.r1}) {output.o1} 2>> {log}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} dedup {params.dpara} --paired --temp-dir {output.td} --stdin={input.bam} --log={log} --stdout={output.bam} 2>> {log} && samtools index {output.bam} 2>> {log}
+
+### umitools.smk
+mkdir -p {output.td} && {params.dedup} dedup {params.dpara} --temp-dir {output.td} --stdin={input.bam} --log={log} --stdout={output.bam} 2>> {log} && samtools index {output.bam} 2>> {log}
+
diff --git a/tests/tool_audit/tool_manifest.yaml b/tests/tool_audit/tool_manifest.yaml
new file mode 100644
index 00000000..3e0c878e
--- /dev/null
+++ b/tests/tool_audit/tool_manifest.yaml
@@ -0,0 +1,380 @@
+# Ground-truth manifest for tests/tool_audit/audit_tool_flags.py
+#
+# Declares, per external tool used by MONSDA workflows, the container it
+# ships in and the exact CLI flags MONSDA hardcodes into workflows/*.smk and
+# workflows/*.nf, so a container/tool version bump can be checked against
+# reality without re-running the whole manual investigation from
+# tests/tool_audit/README.md.
+#
+# This file is the reviewable source of truth: update it by hand whenever a
+# workflow's hardcoded flags change, using
+# `python tests/tool_audit/extract_workflow_commands.py` to regenerate the
+# raw shell-command dumps as a reference while doing so.
+#
+# Schema per tool entry:
+#   container:    .sif basename (without the version suffix), under
+#                 --container-dir
+#   binary:       real on-disk binary name inside the container (may differ
+#                 from the container/env name, e.g. segemehl3 -> segemehl.x)
+#   known_gap:    true if the binary is already known to be missing from the
+#                 container as of this manifest; such gaps are reported as
+#                 informational, not a failure, unless --strict is passed
+#   gap_reason:   human-readable note, required when known_gap is true
+#   na:           true if MONSDA never hardcodes flags for this tool (all
+#                 parameters are user-config-driven); audit is skipped
+#   na_reason:    human-readable note, required when na is true
+#   invocations:  list of checks to run against the tool
+#     name:                 short label for reporting
+#     args:                 argv passed to the binary (help-mode)
+#     expected_flags:       list of flag spellings that must appear in the
+#                           combined stdout+stderr of the invocation
+#     expected_text:        list of arbitrary substrings that must appear
+#                           (for multi-word tokens like SAM attribute tags)
+#     expect_exit:          list of acceptable exit codes (default: [0])
+#     expect_value_required: true if the flag must NOT parse as a
+#                           bare/valueless option (regression check for the
+#                           salmon --writeMappings bug); verified by
+#                           actually invoking the flag with no value and
+#                           asserting a "value required" style error
+#     mode:                 "help" (default) or "minimal_run"
+#     fixture:              (minimal_run) file under fixtures/ to bind in
+#     args_template:        (minimal_run) argv with {fixture}/{tmpdir}
+#                           placeholders
+#     expect_output_exists: (minimal_run) {tmpdir}-templated path that must
+#                           exist after a successful run
+#     source_refs:          workflows/*.smk or *.nf files this backs
+
+tools:
+  oarfish:
+    container: oarfish
+    binary: oarfish
+    invocations:
+      - name: genome-alignments
+        args: ["--help"]
+        expected_flags: ["--genome-alignments", "--annotation", "--genome-fasta", "--threads"]
+        source_refs: [workflows/oarfish.smk, workflows/oarfish.nf]
+        note: >
+          Regression check for the fixed bug: older oarfish used
+          --reference instead of --genome-fasta; --genome-fasta must
+          remain present.
+
+  salmon:
+    container: salmon
+    binary: salmon
+    invocations:
+      - name: index
+        args: ["index", "--help"]
+        expected_flags: ["-d", "--decoys", "-p", "--threads", "-t", "-i"]
+        source_refs: [workflows/salmon.smk, workflows/salmonalign.smk, workflows/kallisto.smk]
+      - name: quant-counting
+        args: ["quant", "--help"]
+        expected_flags: ["-a", "--alignments", "--annotation", "--genome", "--deterministic"]
+        source_refs: [workflows/salmon.smk]
+      - name: quant-writeMappings
+        args: ["quant", "--help"]
+        expected_flags: ["--writeMappings"]
+        expect_value_required: true
+        source_refs: [workflows/salmonalign.smk, workflows/salmonalign.nf]
+        note: >
+          Regression check for the fixed bug: salmon 2.5.1's
+          --writeMappings requires an explicit value (MONSDA passes
+          --writeMappings=/dev/stdout); must fail loudly again if it ever
+          silently becomes value-optional (old behaviour) or is removed.
+
+  kallisto:
+    container: kallisto
+    binary: kallisto
+    invocations:
+      - name: index
+        args: ["index"]
+        expect_exit: [0, 1]
+        expected_flags: ["-d", "--d-list", "-i", "-t", "-k"]
+        source_refs: [workflows/kallisto.smk, workflows/kallisto_trim.smk]
+      - name: quant
+        args: ["quant"]
+        expect_exit: [0, 1]
+        expected_flags: ["-i", "-o", "--single", "-t"]
+        source_refs: [workflows/kallisto.smk, workflows/kallisto_trim.smk]
+
+  bwameth:
+    container: bwameth
+    binary: bwameth.py
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["--reference"]
+        source_refs: [workflows/bwameth.smk]
+        note: "--reference is correct/current here, unlike oarfish/salmon."
+
+  fgumi:
+    container: fgumi
+    binary: fgumi
+    invocations:
+      - name: extract
+        args: ["extract", "--help"]
+        expected_flags: ["--inputs", "--sample", "--library", "--output"]
+        source_refs: [workflows/fgumi.smk]
+
+  piscem:
+    container: piscem
+    binary: piscem
+    invocations:
+      - name: build
+        args: ["build", "--help"]
+        expected_flags: ["-o", "--output", "--decoy-paths", "-k", "-t", "--threads"]
+        source_refs: [workflows/piscem.smk]
+      - name: map-sc
+        args: ["map-sc", "--help"]
+        expected_flags: ["-t", "--threads", "-i", "--index", "-1", "--read1", "-2", "--read2", "-o", "--output"]
+        source_refs: [workflows/piscem.smk]
+
+  alevinfry:
+    container: alevinfry
+    binary: alevin-fry
+    invocations:
+      - name: generate-permit-list
+        args: ["generate-permit-list", "--help"]
+        expected_flags: ["-i", "--input", "-d", "--expected-ori", "-o", "--output-dir", "-t", "--threads", "-m", "--min-reads"]
+        source_refs: [workflows/alevinfry.smk]
+      - name: collate
+        args: ["collate", "--help"]
+        expected_flags: ["-i", "--input-dir", "-r", "--rad-dir", "-t", "--threads"]
+        source_refs: [workflows/alevinfry.smk]
+      - name: quant
+        args: ["quant", "--help"]
+        expected_flags: ["-i", "--input-dir", "-m", "--tg-map", "-o", "--output-dir", "-t", "--threads", "--use-mtx", "-r", "--resolution"]
+        source_refs: [workflows/alevinfry.smk]
+
+  star:
+    container: star
+    binary: STAR
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags:
+          - "runThreadN"
+          - "runMode"
+          - "genomeDir"
+          - "genomeFastaFiles"
+          - "outFileNamePrefix"
+          - "outTmpDir"
+          - "readFilesCommand"
+          - "readFilesIn"
+          - "outReadsUnmapped"
+          - "outSAMtype"
+          - "outSAMattributes"
+        expected_text:
+          - "CR CY UR UY"
+          - "GX GN"
+          - "CB UB"
+          - "sM"
+          - "sS"
+          - "sQ"
+        source_refs: [workflows/star.smk]
+        note: >
+          outSAMattributes tags used by MONSDA (NH HI nM AS CR UR CB UB GX
+          GN sS sQ sM) are documented under the "STARsolo"/"Alignment"
+          sections of the same --help text; matched via expected_text.
+
+  hisat2:
+    container: hisat2
+    binary: hisat2
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["--un-conc", "--summary-file", "--new-summary", "-p", "--threads"]
+        source_refs: [workflows/hisat2.smk]
+        note: "--un-conc-gz is the base --un-conc flag + '-gz' suffix, documented in the same help text."
+
+  macs2:
+    container: macs2
+    binary: macs2
+    invocations:
+      - name: callpeak
+        args: ["callpeak", "--help"]
+        expect_exit: [0, 1]
+        expected_flags: ["-t", "--treatment", "--outdir", "-n", "--name", "-f"]
+        source_refs: [workflows/macs2.smk]
+
+  macs3:
+    container: macs3
+    binary: macs3
+    invocations:
+      - name: callpeak
+        args: ["callpeak", "--help"]
+        expect_exit: [0, 1]
+        expected_flags: ["-t", "--treatment", "--outdir", "-n", "--name", "-f"]
+        source_refs: [workflows/macs3.smk]
+
+  umitools:
+    container: umitools
+    binary: umi_tools
+    invocations:
+      - name: whitelist
+        args: ["whitelist", "--help"]
+        expected_flags: ["--stdin", "--stdout", "--read2-in", "--temp-dir", "--log"]
+        source_refs: [workflows/umicollapse.smk]
+      - name: extract
+        args: ["extract", "--help"]
+        expected_flags: ["--stdin", "--stdout", "--read2-in", "--read2-out", "--error-correct-cell", "--whitelist", "--temp-dir", "--log"]
+        source_refs: [workflows/umicollapse.smk]
+      - name: dedup
+        args: ["dedup", "--help"]
+        expected_flags: ["--stdin", "--stdout", "--paired", "--log", "--temp-dir"]
+        source_refs: [workflows/umitools.smk]
+
+  umicollapse:
+    container: umicollapse
+    binary: umicollapse
+    invocations:
+      - name: bam-dedup
+        mode: minimal_run
+        fixture: tiny.bam
+        args_template: ["bam", "-i", "{fixture}", "-o", "{tmpdir}/out.bam", "--paired"]
+        expect_exit: [0]
+        expect_output_exists: "{tmpdir}/out.bam"
+        source_refs: [workflows/umicollapse.smk]
+        note: >
+          umicollapse's --help exits non-zero with "Missing input file!"
+          before printing usage, so this is checked by actually running a
+          minimal dedup instead of parsing --help text.
+
+  rustqc:
+    container: rustqc
+    binary: rustqc
+    invocations:
+      - name: rna
+        args: ["rna", "--help"]
+        expected_flags: ["--gtf", "-t", "--threads", "-s", "--stranded", "-p", "--paired", "-o", "--outdir", "-j", "--json-summary", "--skip-dup-check"]
+        source_refs: [workflows/rustqc.smk]
+
+  trimgalore:
+    container: trimgalore
+    binary: trim_galore
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["--cores", "--paired", "--gzip", "-o", "--output_dir"]
+        source_refs: [workflows/trimgalore.smk]
+
+  cutadapt:
+    container: cutadapt
+    binary: cutadapt
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["-j", "--cores", "-o", "--output", "-p", "--paired-output"]
+        source_refs: [workflows/cutadapt.smk]
+
+  fastp:
+    container: fastp
+    binary: fastp
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["--in1", "--in2", "--out1", "--out2", "--thread"]
+        source_refs: [workflows/fastp.smk]
+
+  bbduk:
+    container: bbmap
+    binary: bbduk.sh
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["in=", "in2=", "out=", "out2=", "threads="]
+        source_refs: [workflows/bbduk.smk]
+
+  segemehl:
+    container: segemehl
+    binary: segemehl.x
+    invocations:
+      - name: help
+        args: ["--help"]
+        expect_exit: [0, 1]
+        expected_flags: ["-d", "--database", "-x", "--generate", "-q", "--query", "-p", "--mate", "-t", "--threads"]
+        source_refs: [workflows/segemehl.smk]
+
+  segemehl3:
+    container: segemehl3
+    binary: segemehl.x
+    invocations:
+      - name: help
+        args: ["--help"]
+        expect_exit: [0, 1]
+        expected_flags: ["-d", "--database", "-x", "--generate", "-q", "--query", "-p", "--mate", "-t", "--threads"]
+        source_refs: [workflows/segemehl3.smk]
+        note: >
+          The segemehl3 container/env does not ship a binary literally
+          named "segemehl3"; it ships segemehl.x, same as the segemehl
+          container. Not a bug: MONSDA resolves the binary via config
+          (MAPPERBIN), never hardcodes the name "segemehl3".
+
+  minimap:
+    container: minimap
+    binary: minimap2
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["-d", "-t"]
+        source_refs: [workflows/minimap.smk]
+
+  sra:
+    container: sra
+    binary: fasterq-dump
+    invocations:
+      - name: help
+        args: ["--help"]
+        expected_flags: ["-O", "--outdir", "-e", "--threads", "-S", "--split-files"]
+        source_refs: [workflows/sra.smk]
+
+  picard:
+    container: picard
+    binary: picard
+    invocations:
+      - name: MarkDuplicates
+        args: ["MarkDuplicates", "--help"]
+        expect_exit: [0, 1]
+        expected_flags: ["--REMOVE_DUPLICATES", "--ASSUME_SORT_ORDER", "--TMP_DIR", "--INPUT", "--OUTPUT", "--METRICS_FILE"]
+        source_refs: [workflows/picard_dedup.smk]
+
+  piranha:
+    container: piranha
+    binary: Piranha
+    na: true
+    na_reason: >
+      workflows/piranha.smk never hardcodes Piranha CLI flags; all
+      peak-calling parameters come from user config ({params.ppara}).
+
+  # --- Known gaps: containers confirmed missing their expected binary as of
+  # this manifest's creation (see tests/tool_audit/README.md). Reported as
+  # informational unless --strict is passed. Fix by rebuilding the
+  # container, then flip known_gap to false and add real invocations above.
+  scyphy:
+    container: scyphy
+    binary: scyphy
+    known_gap: true
+    gap_reason: "no 'scyphy' binary found in /opt/conda/envs/monsda/bin inside scyphy-1.5.0.sif"
+
+  dorado:
+    container: dorado
+    binary: dorado
+    known_gap: true
+    gap_reason: "no 'dorado' binary found inside dorado-1.5.0.sif"
+
+  guppy:
+    container: guppy
+    binary: guppy_basecaller
+    known_gap: true
+    gap_reason: "no 'guppy_basecaller' binary found inside guppy-1.5.0.sif (env only has gettext tools)"
+
+  ciri2:
+    container: ciri2
+    binary: CIRI2.pl
+    known_gap: true
+    gap_reason: "no 'CIRI2.pl' binary found inside ciri2-1.5.0.sif"
+
+  rustar:
+    container: rustar
+    binary: rustar
+    known_gap: true
+    gap_reason: "no rustar-named binary found inside rustar-1.5.0.sif (only the rust toolchain itself)"

From f7275254606392c7707de6b2914fc3cdd344c283 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 1 Sep 2026 22:48:25 +0200
Subject: [PATCH 57/80] fixed versions for conda envs

---
 envs/alevinfry.yaml | 2 +-
 envs/minimap.yaml   | 2 +-
 envs/oarfish.yaml   | 2 +-
 envs/piscem.yaml    | 2 +-
 envs/salmon.yaml    | 2 +-
 envs/simpleaf.yaml  | 6 +++---
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/envs/alevinfry.yaml b/envs/alevinfry.yaml
index 6e61d630..e2f79c76 100644
--- a/envs/alevinfry.yaml
+++ b/envs/alevinfry.yaml
@@ -4,4 +4,4 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - alevin-fry >=0.11
+  - alevin-fry =0.18.1
diff --git a/envs/minimap.yaml b/envs/minimap.yaml
index 7b536391..4afe0606 100644
--- a/envs/minimap.yaml
+++ b/envs/minimap.yaml
@@ -4,6 +4,6 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - minimap2 >=2.28
+  - minimap2 =2.31
   - pigz =2.6
   - samtools =1.21
\ No newline at end of file
diff --git a/envs/oarfish.yaml b/envs/oarfish.yaml
index 8b791a5b..f8e417e6 100644
--- a/envs/oarfish.yaml
+++ b/envs/oarfish.yaml
@@ -4,5 +4,5 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - oarfish >=0.10
+  - oarfish =0.10.3
   - samtools =1.21
diff --git a/envs/piscem.yaml b/envs/piscem.yaml
index 9b457f9a..77a086d9 100644
--- a/envs/piscem.yaml
+++ b/envs/piscem.yaml
@@ -4,5 +4,5 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - piscem >=0.20
+  - piscem =0.23.0
   - samtools =1.21
diff --git a/envs/salmon.yaml b/envs/salmon.yaml
index a5e45adb..9c9d254d 100644
--- a/envs/salmon.yaml
+++ b/envs/salmon.yaml
@@ -4,6 +4,6 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - salmon >=2.3
+  - salmon =2.7.0
   - samtools =1.21
   - pigz =2.6
\ No newline at end of file
diff --git a/envs/simpleaf.yaml b/envs/simpleaf.yaml
index af9d2e88..1c96f56b 100644
--- a/envs/simpleaf.yaml
+++ b/envs/simpleaf.yaml
@@ -4,7 +4,7 @@ channels:
   - bioconda
   - nodefaults
 dependencies:
-  - simpleaf >=0.25
-  - piscem >=0.20
-  - alevin-fry >=0.11
+  - simpleaf =0.30.0
+  - piscem =0.23.0
+  - alevin-fry =0.18.1
   - pyroe

From d0fa73484401a2c22eaa140ee7fe312e9d608736 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 2 Sep 2026 11:59:46 +0200
Subject: [PATCH 58/80] oarfish cannot handle gzipped gtf files currently fix

---
 tests/tool_audit/README.md                    |  18 ++++++++
 tests/tool_audit/audit_tool_flags.py          |  40 ++++++++++++++++++
 tests/tool_audit/fixtures/README.md           |  13 ++++++
 .../tool_audit/fixtures/tiny_namecollated.bam | Bin 0 -> 315 bytes
 tests/tool_audit/tool_manifest.yaml           |  38 +++++++++++++++++
 workflows/oarfish.nf                          |   2 +-
 workflows/oarfish.smk                         |   3 +-
 7 files changed, 112 insertions(+), 2 deletions(-)
 create mode 100644 tests/tool_audit/fixtures/tiny_namecollated.bam

diff --git a/tests/tool_audit/README.md b/tests/tool_audit/README.md
index e61c1ac6..5abeba1b 100644
--- a/tests/tool_audit/README.md
+++ b/tests/tool_audit/README.md
@@ -55,6 +55,24 @@ findings into the prose sections below by hand after fixing them.
 `error: unexpected argument '--reference' found`.
 Fixed in workflows/oarfish.smk and workflows/oarfish.nf.
 
+### oarfish - gzipped GTF annotation not supported (fixed)
+Separately from the flag rename above: oarfish 0.10.3's genome-mode
+annotation loader cannot infer the format of a `.gtf.gz`/`.gff.gz` file
+and fails with `Error: failed to load annotation ...` /
+`unable to detect annotation format from extension: .gz`, even though
+`--genome-fasta` happily accepts a gzipped genome FASTA in the same run.
+Reproduced with a minimal name-collated BAM + gzipped GTF + gzipped FASTA
+in the container; confirmed the identical run succeeds once the GTF is
+decompressed to plain `.gtf` first. MONSDA's GENOMES/ dir stores
+`genes.gtf.gz`, so every real run hit this. Fixed by decompressing the
+annotation with `zcat -f` into the job's output dir before invoking
+oarfish, and cleaning it up afterwards, in both workflows/oarfish.smk and
+workflows/oarfish.nf. Tracked as a regression probe in
+tool_manifest.yaml's `oarfish.gzipped-annotation-unsupported` invocation
+(uses tests/tool_audit/fixtures/tiny_namecollated.bam) so a future oarfish
+release adding native gzip support for `--annotation` shows up as that
+probe's expected error text going away.
+
 ### salmonalign (fixed)
 salmon in the container (salmon-1.5.0.sif) is salmon 2.5.1, a full Rust
 rewrite. `--writeMappings` now REQUIRES an explicit filename value
diff --git a/tests/tool_audit/audit_tool_flags.py b/tests/tool_audit/audit_tool_flags.py
index 67fd52d7..ae8b5dd1 100755
--- a/tests/tool_audit/audit_tool_flags.py
+++ b/tests/tool_audit/audit_tool_flags.py
@@ -157,12 +157,35 @@ def check_help_invocation(tool, container_name, binary, sif, inv, timeout):
     return Result(tool, name, STATUS_PASS, "ok")
 
 
+def run_prep_steps(prep, tmpdir, fixture_path):
+    """Execute manifest-declared `prep` steps (write/gzip) before a
+    minimal_run invocation, so fixtures needing more than one static file
+    (e.g. the oarfish gzipped-GTF regression probe) don't need to be
+    checked into fixtures/ as binary blobs."""
+    for step in prep or []:
+        if "write" in step:
+            target = Path(step["write"].format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir))
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(step.get("content", ""))
+        elif "gzip" in step:
+            import gzip as gzip_module
+
+            src = Path(step["gzip"].format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir))
+            dest = Path(step["dest"].format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir))
+            with open(src, "rb") as fh_in, gzip_module.open(dest, "wb") as fh_out:
+                fh_out.write(fh_in.read())
+        else:
+            raise ValueError(f"unknown prep step: {step}")
+
+
 def check_minimal_run_invocation(tool, container_name, binary, sif, inv, timeout, fixtures_dir):
     name = inv.get("name", "minimal_run")
     fixture = inv.get("fixture")
     expect_exit = inv.get("expect_exit", [0])
     args_template = inv.get("args_template", [])
     expect_output_exists = inv.get("expect_output_exists")
+    expect_stderr_contains = inv.get("expect_stderr_contains", [])
+    prep = inv.get("prep")
 
     fixture_path = fixtures_dir / fixture if fixture else None
     if fixture_path is not None and not fixture_path.exists():
@@ -171,6 +194,11 @@ def check_minimal_run_invocation(tool, container_name, binary, sif, inv, timeout
         )
 
     with tempfile.TemporaryDirectory() as tmpdir:
+        try:
+            run_prep_steps(prep, tmpdir, fixture_path)
+        except Exception as e:
+            return Result(tool, name, STATUS_GAP, f"prep step failed: {e}")
+
         args = [
             a.format(fixture=str(fixture_path) if fixture_path else "", tmpdir=tmpdir)
             for a in args_template
@@ -201,6 +229,18 @@ def check_minimal_run_invocation(tool, container_name, binary, sif, inv, timeout
                     tool, name, STATUS_DRIFT, f"expected output not created: {out_path}"
                 )
 
+        if expect_stderr_contains:
+            missing_text = [t for t in expect_stderr_contains if t not in err]
+            if missing_text:
+                return Result(
+                    tool,
+                    name,
+                    STATUS_DRIFT,
+                    f"expected stderr text not found (message may have changed "
+                    f"or the underlying issue may be fixed upstream): {missing_text}; "
+                    f"stderr head: {err.strip()[:300]!r}",
+                )
+
     return Result(tool, name, STATUS_PASS, "ok")
 
 
diff --git a/tests/tool_audit/fixtures/README.md b/tests/tool_audit/fixtures/README.md
index 8431f935..367a6a34 100644
--- a/tests/tool_audit/fixtures/README.md
+++ b/tests/tool_audit/fixtures/README.md
@@ -23,3 +23,16 @@ Verified this dedups to 2 reads via:
 
     apptainer exec --bind $PWD:$PWD ~/Work2/Container/MONSDA/umicollapse-1.5.0.sif \
         umicollapse bam -i $PWD/tiny.bam -o $PWD/out.bam --paired
+
+## tiny_namecollated.bam
+
+Same 3 reads as tiny.bam, but collated by read name (not coordinate-sorted)
+via `samtools collate`, since oarfish's `--genome-alignments` genome-mode
+projection refuses coordinate-sorted input ("oarfish cannot project a
+coordinate-sorted genome BAM"). Used by the oarfish
+`gzipped-annotation-unsupported` regression probe.
+
+Regenerate with (inside the `apptainer` conda env):
+
+    apptainer exec ~/Work2/Container/MONSDA/umicollapse-1.5.0.sif \
+        samtools collate -o tiny_namecollated.bam tiny.bam
diff --git a/tests/tool_audit/fixtures/tiny_namecollated.bam b/tests/tool_audit/fixtures/tiny_namecollated.bam
new file mode 100644
index 0000000000000000000000000000000000000000..637234baaef30132a93ca1e1d21515eddc88edb4
GIT binary patch
literal 315
zcmb2|=3rp}f&Xj_PR>jW`xuIgzNFS1I&k2@gNKJCpQWd+NIxd|CO>pm_?-BVNwW^U
ze3u^@F)J$M<Wm8e6OwPzr_KpXIq~vwdTK^O!hxp(56-=OnG`x_M)ail^MlVwK4?#9
zK5Jz3q~u#;x8{`8Wz)1@sA;}<radL)S?DWO)n`r;M>}`EXnQHSNJ3noAtBk=%F<q4
zeWQwKN=aN&p4ODvO&gRn4X1ZcY;0_t+SthWgtJZj3=a>3c>L>se}S%+M{|BWgK@G0
zgPgR#q8l3<n;08g+y4LtA$_Bs@{%%s#zZ!Dpr|50FAx|{5D78$n|th|qM{<lTv^!@
gR*nqI{gh|S?ei#OV%YjT<mx&s=1Vg$g8~Z-0CL-LdjJ3c

literal 0
HcmV?d00001

diff --git a/tests/tool_audit/tool_manifest.yaml b/tests/tool_audit/tool_manifest.yaml
index 3e0c878e..92faaa68 100644
--- a/tests/tool_audit/tool_manifest.yaml
+++ b/tests/tool_audit/tool_manifest.yaml
@@ -57,6 +57,44 @@ tools:
           Regression check for the fixed bug: older oarfish used
           --reference instead of --genome-fasta; --genome-fasta must
           remain present.
+      - name: gzipped-annotation-unsupported
+        mode: minimal_run
+        fixture: tiny_namecollated.bam
+        args_template:
+          - "--genome-alignments"
+          - "{fixture}"
+          - "--annotation"
+          - "{tmpdir}/annotation.gtf.gz"
+          - "--genome-fasta"
+          - "{tmpdir}/genome.fa.gz"
+          - "--output"
+          - "{tmpdir}/oarfish_gz_probe"
+        prep:
+          - write: "{tmpdir}/annotation.gtf"
+            content: |
+              chr1	test	transcript	1	100	.	+	.	gene_id "g1"; transcript_id "t1";
+              chr1	test	exon	1	100	.	+	.	gene_id "g1"; transcript_id "t1";
+          - gzip: "{tmpdir}/annotation.gtf"
+            dest: "{tmpdir}/annotation.gtf.gz"
+          - write: "{tmpdir}/genome.fa"
+            content: ">chr1\nACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT\n"
+          - gzip: "{tmpdir}/genome.fa"
+            dest: "{tmpdir}/genome.fa.gz"
+        expect_exit: [1]
+        expect_stderr_contains: ["unable to detect annotation format from extension"]
+        source_refs: [workflows/oarfish.smk, workflows/oarfish.nf]
+        note: >
+          Documents/tracks a real (non-CLI-flag) bug found this session:
+          oarfish 0.10.3 cannot load a gzipped GTF/GFF for --annotation in
+          genome mode ("unable to detect annotation format from extension:
+          .gz"), even though --genome-fasta happily accepts gzipped FASTA.
+          workflows/oarfish.smk/.nf now decompress the annotation to a
+          plain .gtf via `zcat -f` before invoking oarfish. This probe
+          documents the upstream limitation so it is easy to notice (via a
+          DRIFT going away, i.e. exit code no longer 1 / message text
+          changing) if/when a future oarfish release adds native gzip
+          support for --annotation, at which point the manifest and the
+          decompression workaround in the workflows can both be reverted.
 
   salmon:
     container: salmon
diff --git a/workflows/oarfish.nf b/workflows/oarfish.nf
index ed19a714..79164d58 100644
--- a/workflows/oarfish.nf
+++ b/workflows/oarfish.nf
@@ -35,7 +35,7 @@ process oarfish_quant{
     oz = fn+"/quant.sf.gz"
     ol = fn+"_counts.gz"
     """
-    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $COUNTANNO --genome-fasta $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
+    mkdir -p $fn; samtools collate -@ ${task.cpus} -o namecollated.bam $bam &>> $lf; zcat -f $COUNTANNO > $fn/annotation.gtf 2>> $lf; $COUNTBIN --threads ${task.cpus} --genome-alignments namecollated.bam --annotation $fn/annotation.gtf --genome-fasta $COUNTREF $COUNTPARAMS --output $fn/oarfish &>> $lf && rm -f namecollated.bam $fn/annotation.gtf && gzip -c $fn/oarfish.quant > $oz && ln -fs $oz $ol
     """
 }
 
diff --git a/workflows/oarfish.smk b/workflows/oarfish.smk
index 26e8acb8..0c040128 100644
--- a/workflows/oarfish.smk
+++ b/workflows/oarfish.smk
@@ -21,6 +21,7 @@ rule mapping:
     params: cpara = lambda wildcards: tool_params(wildcards.file, None, config, 'COUNTING', COUNTENV)['OPTIONS'].get('COUNT', ""),
             mapp = COUNTBIN,
             nbam = lambda wildcards, output: os.path.join(str(output.ctsdir), "namecollated.bam"),
+            anno = lambda wildcards, output: os.path.join(str(output.ctsdir), "annotation.gtf"),
             prefix = lambda wildcards, output: os.path.join(str(output.ctsdir), "oarfish"),
             linksf = lambda wildcards, output: str(os.path.abspath(output.ctsdir))
-    shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {input.anno} --genome-fasta {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"
+    shell: "set +euo pipefail; mkdir -p {output.ctsdir}; samtools collate -@ {threads} -o {params.nbam} {input.bam} &>> {log}; zcat -f {input.anno} > {params.anno} 2>> {log}; {params.mapp} --threads {threads} --genome-alignments {params.nbam} --annotation {params.anno} --genome-fasta {input.fa} {params.cpara} --output {params.prefix} &>> {log} && rm -f {params.nbam} {params.anno} && gzip -c {params.prefix}.quant > {output.ctsdir}/quant.sf.gz ; ln -fs {params.linksf}/quant.sf.gz {output.cnts} &>> {log}"

From 2a6e359f2a198615321d9e9138cf13f438fc72d2 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 18 Sep 2026 11:49:28 +0200
Subject: [PATCH 59/80] updated multiqc report with rastqc enabled and
 corresponding tests

---
 MONSDA/Workflows.py                                    |  2 +-
 .../smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk   |  6 +++---
 .../smk/Test_fastqc-bbduk-picard-star_subsnake.smk     |  6 +++---
 .../Test_fastqc-cutadapt-picard-rustar_subsnake.smk    |  6 +++---
 .../smk/Test_fastqc-cutadapt-picard-star_subsnake.smk  |  6 +++---
 .../Test_fastqc-trimgalore-picard-rustar_subsnake.smk  |  6 +++---
 .../Test_fastqc-trimgalore-picard-star_subsnake.smk    |  6 +++---
 workflows/multiqc_rustqc.nf                            |  5 +++--
 workflows/multiqc_rustqc.smk                           | 10 ++++++----
 workflows/rustar.smk                                   |  6 +++---
 workflows/star.smk                                     |  6 +++---
 11 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 4757bdfe..d13516ef 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -418,7 +418,7 @@ def get_combo(wfs, config, conditions):
             # Group all QC tools into a single combo position so pre-QC
             # (fastqc) and post-QC (rustqc) both appear in one combo name.
             if subwork == "QC" and len(tools) > 1:
-                qc_prio = {"fastqc": 0, "rustqc": 1}
+                qc_prio = {"fastqc": 0, "rastqc": 0, "rustqc": 1}
                 tools = sorted(
                     tools,
                     key=lambda item: (
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
index 874f8515..2d5a4e70 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-rustar_subsnake.smk
@@ -505,7 +505,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -527,7 +527,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -550,7 +550,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
index cda06755..867d038a 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-bbduk-picard-star_subsnake.smk
@@ -506,7 +506,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -528,7 +528,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -551,7 +551,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
index 171f1201..6419a4ee 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-rustar_subsnake.smk
@@ -505,7 +505,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -527,7 +527,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -550,7 +550,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
index 0c2145d5..bb1c8ba3 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-cutadapt-picard-star_subsnake.smk
@@ -506,7 +506,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -528,7 +528,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -551,7 +551,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
index 1c557b42..73d5b6e6 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-rustar_subsnake.smk
@@ -512,7 +512,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -534,7 +534,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -557,7 +557,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
index 5cc08cc2..b94e00e5 100644
--- a/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
+++ b/tests/golden/config_Test/smk/Test_fastqc-trimgalore-picard-star_subsnake.smk
@@ -513,7 +513,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -535,7 +535,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
@@ -558,7 +558,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda: "<REPO>/envs/"+MAPPERENV+".yaml"
diff --git a/workflows/multiqc_rustqc.nf b/workflows/multiqc_rustqc.nf
index fd217477..9df27e14 100644
--- a/workflows/multiqc_rustqc.nf
+++ b/workflows/multiqc_rustqc.nf
@@ -1,6 +1,7 @@
 MQCENV=get_always('POSTQCENV')
 MQCBIN=get_always('POSTQCBIN')
 MQCPARAMS = get_always('rustqc_params_MULTI') ?: ''
+PREQCENV = get_always('PREQCENV') ?: 'fastqc'
 
 process mqc{
     conda "$MQCENV"+".yaml"
@@ -42,8 +43,8 @@ process mqc{
         SCAN="\$SCAN \$QC_DIR"
     fi
 
-    # If the corresponding fastqc combo exists, include its output in the MultiQC report.
-    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/fastqc}/\${CONDITION_VAL}"
+    # If the corresponding pre-QC combo (fastqc/rastqc/...) exists, include its output in the MultiQC report.
+    FQ_DIR="\${BASE_QC_DIR}/\${COMBO_VAL/rustqc/${PREQCENV}}/\${CONDITION_VAL}"
     if [[ "\$FQ_DIR" != "\$QC_DIR" && -d "\$FQ_DIR" ]]; then
         SCAN="\$SCAN \$FQ_DIR"
     fi
diff --git a/workflows/multiqc_rustqc.smk b/workflows/multiqc_rustqc.smk
index 8505961e..b5ebba13 100644
--- a/workflows/multiqc_rustqc.smk
+++ b/workflows/multiqc_rustqc.smk
@@ -10,8 +10,9 @@ if paired == 'paired':
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
-        params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', ""),
+                preqcenv = config.get('PREQCENV', 'fastqc')
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/{params.preqcenv}/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
 
 else:
     rule multiqc:
@@ -25,5 +26,6 @@ else:
         conda:  "rustqc.yaml"
         container: "oras://jfallmann/monsda:rustqc"
         threads: 1
-        params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', "")
-        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/fastqc/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
+        params: qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('MULTI', ""),
+                preqcenv = config.get('PREQCENV', 'fastqc')
+        shell:  "OUT=$(dirname {output.html}); mkdir -p $OUT; SCAN=LOGS/{wildcards.combo}/{wildcards.condition}; for d in QC/{wildcards.combo}/{wildcards.condition} QC/$(echo {wildcards.combo}|sed 's/rustqc/{params.preqcenv}/g')/{wildcards.condition}; do case \" $SCAN \" in *\" $d \"*) continue;; esac; if [ -d \"$d\" ]; then SCAN=\"$SCAN $d\"; fi; done; MODS=$(grep -v '^#' {input.versions}|cut -f3|tr ',' '\\n'|grep -vx '-'|sort -u|sed 's/^/-m /'|tr '\\n' ' ');export LC_ALL=C.UTF-8; multiqc -f {params.qpara} $MODS -k json -z -s -o $OUT $SCAN 2>> {log}; cp -f {input.versions} $OUT/"
diff --git a/workflows/rustar.smk b/workflows/rustar.smk
index 2b478fb5..ac16fc78 100644
--- a/workflows/rustar.smk
+++ b/workflows/rustar.smk
@@ -34,7 +34,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
@@ -57,7 +57,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
@@ -80,7 +80,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/RUSTAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
diff --git a/workflows/star.smk b/workflows/star.smk
index f94e75dd..0f3972d4 100644
--- a/workflows/star.smk
+++ b/workflows/star.smk
@@ -35,7 +35,7 @@ if paired == 'paired':
                 unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                 unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                 log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                 tmp = temp("TMP/STAROUT/{combo}/{file}")
         log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
         conda:  ""+MAPPERENV+".yaml"
@@ -58,7 +58,7 @@ else:
             output: mapped = temp(report("MAPPED/{combo}/{file}_mapped.sam.gz", category="MAPPING")),
                     unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")                    
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"
@@ -81,7 +81,7 @@ else:
                     unmapped_r1 = "UNMAPPED/{combo}/{file}_R1_unmapped.fastq.gz",
                     unmapped_r2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz",
                     log = "LOGS/{combo}/{file}/MAPPING/star/Log.out",
-                    log_final = "LOGS/{combo}/{file}/MAPPING/star/Log.final.out",
+                    log_final = "LOGS/{combo}/{file}/MAPPING/star/{file}_Log.final.out",
                     tmp = temp("TMP/STAROUT/{combo}/{file}")
             log:    "LOGS/{combo}/{file}/MAPPING/star/mapping.log"
             conda:  ""+MAPPERENV+".yaml"

From 016cbcc388e1ed2fe008df130e577aaedbc166cf Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Mon, 5 Oct 2026 22:39:33 +0200
Subject: [PATCH 60/80] overhaul of DE logic before summary update

---
 scripts/Analysis/DE/DESEQ2.R           |  54 ++++-------
 scripts/Analysis/DE/EDGER.R            |  30 +++---
 scripts/Analysis/filter_significant.py | 128 +++++++++++++++++++++++++
 scripts/lib/_lib.R                     |  84 ++++++++++++++++
 workflows/deseq2_DE.nf                 |   3 +-
 workflows/deseq2_DE.smk                |   5 +-
 workflows/edger_DE.nf                  |   3 +-
 7 files changed, 259 insertions(+), 48 deletions(-)
 create mode 100755 scripts/Analysis/filter_significant.py

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index f934176f..96a1699e 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -51,7 +51,8 @@ gtf.df <- as.data.frame(gtf.rtl)
 gtf_gene <- droplevels(subset(gtf.df, type == "gene"))
 
 ## Combinations of conditions
-comparison <- strsplit(cmp, ",")
+comparison <- parse_comparisons(cmp)
+validate_comparisons(comparison, levels(sampleData_all$condition))
 
 ## check combi
 if (combi == "none") {
@@ -114,7 +115,7 @@ print(design)
 dds <- DESeqDataSetFromMatrix(countData = countData_all, colData = sampleData_all, design = design)
 
 # filter low counts
-smallestGroupSize <- length(unique(sampleData_all$condition))
+smallestGroupSize <- min_group_size(sampleData_all$condition)
 keep <- rowSums(counts(dds) >= 10) >= smallestGroupSize
 dds <- dds[keep, ]
 
@@ -194,19 +195,18 @@ dev.off()
 
 ### Now we run comparisons
 
-for (contrast in comparison[[1]]) {
-    contrast_name <- strsplit(contrast, ":")[[1]][1]
-    contrast_groups <- strsplit(strsplit(contrast, ":")[[1]][2], "-vs-")
+for (contrast in comparison) {
+    contrast_name <- contrast$name
     print(paste("Comparing ", contrast_name, sep = ""))
 
     # determine contrast
-    A <- unlist(strsplit(contrast_groups[[1]][1], "\\+"), use.names = FALSE)
-    B <- unlist(strsplit(contrast_groups[[1]][2], "\\+"), use.names = FALSE)
+    A <- contrast$A
+    B <- contrast$B
 
-    # subset Datasets for pairwise comparison
-    countData <- cbind(countData_all[, grepl(paste("^", B, "_", sep = ""), colnames(countData_all))], countData_all[, grepl(paste("^", A, "_", sep = ""), colnames(countData_all))])
-    rownames(countData) <- rownames(countData_all)
-    sampleData <- droplevels(rbind(subset(sampleData_all, B == condition), subset(sampleData_all, A == condition)))
+    # subset Datasets for pairwise comparison: metadata-based selection, B then A order
+    sel <- select_contrast_samples(sampleData_all, countData_all, A, B)
+    sampleData <- sel$sampleData
+    countData <- sel$countData
 
     ## Create design-table considering different types (paired, unpaired) and batches
     if (length(unique(subset(sampleData, A == condition)$type)) > 1 | length(unique(subset(sampleData, B == condition)$type)) > 1) {
@@ -241,7 +241,7 @@ for (contrast in comparison[[1]]) {
 
         dds_norm <- DESeqDataSetFromMatrix(countData = counts(counts_norm), colData = sampleData_norm, design = design_norm)
         # filter low counts
-        smallestGroupSize <- length(unique(sampleData_norm$condition))
+        smallestGroupSize <- min_group_size(sampleData_norm$condition)
         keep_norm <- rowSums(counts(dds_norm) >= 10) >= smallestGroupSize
         dds_norm <- dds_norm[keep_norm, ]
 
@@ -269,7 +269,7 @@ for (contrast in comparison[[1]]) {
     dds <- DESeqDataSetFromMatrix(countData = countData, colData = sampleData, design = design)
 
     # filter low counts
-    smallestGroupSize <- length(unique(sampleData$condition))
+    smallestGroupSize <- min_group_size(sampleData$condition)
     keep <- rowSums(counts(dds) >= 10) >= smallestGroupSize
     dds <- dds[keep, ]
 
@@ -312,12 +312,7 @@ for (contrast in comparison[[1]]) {
         resOrdered <- res_shrink[order(res_shrink$log2FoldChange), ]
 
         # # Add gene names  (check how gene_id col is named )
-        resOrdered$Gene <- unlist(lapply(rownames(resOrdered), function(x) {
-            get_gene_name(x, gtf_gene)
-        }))
-        resOrdered$Gene_ID <- rownames(resOrdered)
-        resOrdered <- resOrdered[, c(7, 6, 1, 2, 3, 4, 5)]
-        resOrdered <- add_gene_coordinates(resOrdered, resOrdered$Gene_ID, gtf_gene, after = "Gene_ID")
+        resOrdered <- format_deseq2_results(resOrdered, gtf_gene, shrink = TRUE)
 
         # plotVolcano
         pdf(
@@ -353,12 +348,11 @@ for (contrast in comparison[[1]]) {
         # sort and output
         res <- resn[order(resn$log2FoldChange), ]
 
-        res$Gene <- lapply(rownames(res), function(x) {
+        res$Gene <- unlist(lapply(rownames(res), function(x) {
             get_gene_name(x, gtf_gene)
-        })
+        }))
         res$Gene_ID <- rownames(res)
-        res <- res[, c(8, 7, 1, 2, 3, 5, 6)]
-        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+        res <- format_deseq2_results(res, gtf_gene, shrink = FALSE)
         res <- as.data.frame(apply(res, 2, as.character))
 
         write.table(as.data.frame(res), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "results_noshrink.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
@@ -385,12 +379,7 @@ for (contrast in comparison[[1]]) {
             resOrdered <- res_shrink[order(res_shrink$log2FoldChange), ]
 
             # # Add gene names  (check how gene_id col is named )
-            resOrdered$Gene <- unlist(lapply(rownames(resOrdered), function(x) {
-                get_gene_name(x, gtf_gene)
-            }))
-            resOrdered$Gene_ID <- rownames(resOrdered)
-            resOrdered <- resOrdered[, c(7, 6, 1, 2, 3, 4, 5)]
-            resOrdered <- add_gene_coordinates(resOrdered, resOrdered$Gene_ID, gtf_gene, after = "Gene_ID")
+            resOrdered <- format_deseq2_results(resOrdered, gtf_gene, shrink = TRUE)
 
             # plot Volcano
             pdf(
@@ -426,12 +415,11 @@ for (contrast in comparison[[1]]) {
             # sort and output
             res <- resn[order(resn$log2FoldChange), ]
 
-            res$Gene <- lapply(rownames(res), function(x) {
+            res$Gene <- unlist(lapply(rownames(res), function(x) {
                 get_gene_name(x, gtf_gene)
-            })
+            }))
             res$Gene_ID <- rownames(res)
-            res <- res[, c(7, 6, 1, 2, 3, 4, 5)]
-            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+            res <- format_deseq2_results(res, gtf_gene, shrink = FALSE)
             res <- as.data.frame(apply(res, 2, as.character))
 
             write.table(as.data.frame(res), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "results_norm_noshrink.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 350c29f3..b17558e1 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -68,7 +68,8 @@ sampleData_all$type <- as.factor(sampleData_all$type)
 samples <- rownames(sampleData_all)
 
 ## Combinations of conditions
-comparison <- strsplit(cmp, ",")
+comparison <- parse_comparisons(cmp)
+validate_comparisons(comparison, levels(sampleData_all$condition))
 
 ## check combi
 if (combi == "none") {
@@ -173,20 +174,19 @@ plotQLDisp(fit)
 dev.off()
 
 ## Analyze according to comparison groups
-for (contrast in comparison[[1]]) {
-    contrast_name <- strsplit(contrast, ":")[[1]][1]
-    contrast_groups <- strsplit(strsplit(contrast, ":")[[1]][2], "-vs-")
+for (contrast in comparison) {
+    contrast_name <- contrast$name
 
     print(paste("Comparing ", contrast_name, sep = ""))
 
     # determine contrast
-    A <- unlist(strsplit(contrast_groups[[1]][1], "\\+"), use.names = FALSE)
-    B <- unlist(strsplit(contrast_groups[[1]][2], "\\+"), use.names = FALSE)
+    A <- contrast$A
+    B <- contrast$B
 
-    # subset Datasets for pairwise comparison
-    countData <- cbind(countData_all[, grepl(paste("^", B, "_", sep = ""), colnames(countData_all))], countData_all[, grepl(paste("^", A, "_", sep = ""), colnames(countData_all))])
-    rownames(countData) <- rownames(countData_all)
-    sampleData <- droplevels(rbind(subset(sampleData_all, B == condition), subset(sampleData_all, A == condition)))
+    # subset Datasets for pairwise comparison: metadata-based selection, B then A order
+    sel <- select_contrast_samples(sampleData_all, countData_all, A, B)
+    sampleData <- sel$sampleData
+    countData <- sel$countData
     sampleData$condition <- relevel(sampleData$condition, ref = B)
 
     samples <- rownames(sampleData)
@@ -261,6 +261,9 @@ for (contrast in comparison[[1]]) {
         dev.off()
 
         ## estimate Dispersion
+        if (no_residual_df(design_norm)) {
+            stop(paste0("Spike-in normalized design for contrast ", contrast_name, " has no residual degrees of freedom (", nrow(design_norm), " samples, design rank ", qr(design_norm)$rank, "). The nuisance-adjusted model cannot be fit; refusing to fall back to an unadjusted test that ignores the covariates."))
+        }
         dge_norm <- estimateDisp(dge_norm, design_norm, robust = TRUE)
 
         ## create file BCV-plot - visualizing estimated dispersions
@@ -448,7 +451,12 @@ for (contrast in comparison[[1]]) {
 
             ## Testing
             # qlf <- glmQLFTest(fit, contrast=contrast) ## glm quasi-likelihood-F-Test
-            AvsB <- makeContrasts(TreatvsUntreat = paste("W_1 + condition", A, sep = ""), levels = design_norm)
+            contrast_col <- paste0("condition", A)
+            if (!contrast_col %in% colnames(design_norm)) {
+                stop(paste0("Spike-in design has no column '", contrast_col, "' (columns: ", paste(colnames(design_norm), collapse = ", "), ")"))
+            }
+            AvsB <- setNames(numeric(ncol(design_norm)), colnames(design_norm))
+            AvsB[contrast_col] <- 1
             qlf <- glmQLFTest(fit_norm, contrast = AvsB) ## glm quasi-likelihood-F-Test
             # add comp object to list for image
             comparison_objs <- append(comparison_objs, qlf)
diff --git a/scripts/Analysis/filter_significant.py b/scripts/Analysis/filter_significant.py
new file mode 100755
index 00000000..75e85eb0
--- /dev/null
+++ b/scripts/Analysis/filter_significant.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Header-aware significant-hit filter for DE result tables.
+
+Replaces the positional Perl one-liners in the deseq2_DE/edger_DE workflows.
+Columns are located by header name, so adding or reordering annotation columns
+(Coordinates, stat, ...) cannot silently shift the tested fields.
+
+A row is kept when the adjusted p-value is strictly below --p-cutoff and the
+absolute effect size is at least --lfc-cutoff. Only finite values in the two
+required columns are evaluated; missing optional annotation columns (e.g.
+Coordinates, Gene) or an NA in an optional column such as edgeR's F do not
+discard a row. Non-numeric values in a required column are treated as malformed
+input and abort with a clear error. Header-only inputs produce gzip outputs
+containing only the header.
+"""
+
+import argparse
+import gzip
+import math
+import sys
+
+NON_FINITE = {"", "NA", "N/A", "NaN", "nan", "Inf", "-Inf", "inf", "-inf"}
+
+
+def open_maybe_gzip(path):
+    if path.endswith(".gz"):
+        return gzip.open(path, "rt", encoding="utf-8", newline="")
+    return open(path, "r", encoding="utf-8", newline="")
+
+
+def read_header(handle):
+    line = handle.readline()
+    if not line:
+        raise ValueError("input file is empty, no header line found")
+    header = line.rstrip("\n").split("\t")
+    if not header or any(not col for col in header):
+        raise ValueError("malformed header line")
+    return header
+
+
+def parse_required(value, colname, lineno):
+    stripped = value.strip()
+    if stripped in NON_FINITE:
+        return None
+    try:
+        return float(stripped)
+    except ValueError:
+        raise ValueError(
+            "line %d: non-numeric value %r in required column %r"
+            % (lineno, value, colname)
+        )
+
+
+def filter_table(inpath, effect_col, adjp_col, p_cut, lfc_cut, out_sig, out_up, out_down):
+    with open_maybe_gzip(inpath) as fh:
+        header = read_header(fh)
+        if effect_col not in header:
+            raise ValueError(
+                "effect column %r not found in header: %s" % (effect_col, header)
+            )
+        if adjp_col not in header:
+            raise ValueError(
+                "adjusted p column %r not found in header: %s" % (adjp_col, header)
+            )
+        eidx = header.index(effect_col)
+        aidx = header.index(adjp_col)
+        header_line = "\t".join(header) + "\n"
+        with gzip.open(out_sig, "wt", encoding="utf-8", newline="") as sig, \
+             gzip.open(out_up, "wt", encoding="utf-8", newline="") as up, \
+             gzip.open(out_down, "wt", encoding="utf-8", newline="") as down:
+            sig.write(header_line)
+            up.write(header_line)
+            down.write(header_line)
+            for lineno, line in enumerate(fh, start=2):
+                if not line.strip():
+                    continue
+                fields = line.rstrip("\n").split("\t")
+                if len(fields) != len(header):
+                    raise ValueError(
+                        "line %d: expected %d fields, got %d"
+                        % (lineno, len(header), len(fields))
+                    )
+                pval = parse_required(fields[aidx], adjp_col, lineno)
+                lfc = parse_required(fields[eidx], effect_col, lineno)
+                if pval is None or lfc is None:
+                    continue
+                if not (math.isfinite(pval) and math.isfinite(lfc)):
+                    continue
+                if pval < p_cut and abs(lfc) >= lfc_cut:
+                    sig.write(line)
+                    if lfc >= lfc_cut:
+                        up.write(line)
+                    if lfc <= -lfc_cut:
+                        down.write(line)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Filter a DE result table for significant hits by column name."
+    )
+    parser.add_argument("--effect-column", required=True, help="effect size column (log2FoldChange/logFC)")
+    parser.add_argument("--adjusted-p-column", required=True, help="adjusted p-value column (padj/FDR)")
+    parser.add_argument("--p-cutoff", required=True, type=float, help="adjusted p-value cutoff (strict <)")
+    parser.add_argument("--lfc-cutoff", required=True, type=float, help="absolute log fold change cutoff (>=)")
+    parser.add_argument("--input", required=True, help="input result table (plain or gzip)")
+    parser.add_argument("--output-sig", required=True, help="gzip output with all significant rows")
+    parser.add_argument("--output-up", required=True, help="gzip output with up-regulated rows")
+    parser.add_argument("--output-down", required=True, help="gzip output with down-regulated rows")
+    args = parser.parse_args(argv)
+    try:
+        filter_table(
+            args.input,
+            args.effect_column,
+            args.adjusted_p_column,
+            args.p_cutoff,
+            args.lfc_cutoff,
+            args.output_sig,
+            args.output_up,
+            args.output_down,
+        )
+    except (OSError, ValueError) as exc:
+        print("filter_significant: %s" % exc, file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/lib/_lib.R b/scripts/lib/_lib.R
index fbe40116..90086eed 100644
--- a/scripts/lib/_lib.R
+++ b/scripts/lib/_lib.R
@@ -102,3 +102,87 @@ calc_tpm <- function(counts, gtf) {
     tpm <- t(t(rpk) / scaling_factors * 1e6)
     return(tpm)
 }
+
+## Minimum number of samples in any non-empty condition group, used for the
+## low-count prefilter. Empty factor levels are dropped first so that a group
+## without samples cannot silently keep every gene.
+min_group_size <- function(cond) {
+    tab <- table(droplevels(factor(cond)))
+    if (length(tab) == 0) {
+        stop("No non-empty condition groups available for the low-count filter")
+    }
+    min(tab)
+}
+
+## Parse a MONSDA comparison string ("name:A+B-vs-C+D,...") into a list of
+## contrasts with named A (numerator) and B (denominator) group vectors.
+parse_comparisons <- function(cmp) {
+    lapply(strsplit(cmp, ",")[[1]], function(contrast) {
+        name <- strsplit(contrast, ":")[[1]][1]
+        groups <- strsplit(strsplit(contrast, ":")[[1]][2], "-vs-")[[1]]
+        list(
+            name = name,
+            A = unlist(strsplit(groups[1], "\\+"), use.names = FALSE),
+            B = unlist(strsplit(groups[2], "\\+"), use.names = FALSE)
+        )
+    })
+}
+
+## Validate that every comparison is a pairwise contrast between two distinct,
+## existing condition groups. Compound groups (pooled or weighted semantics)
+## are not supported and rejected with a clear error before any fit runs.
+validate_comparisons <- function(parsed, condition_levels) {
+    for (cmp in parsed) {
+        if (length(cmp$A) != 1 || length(cmp$B) != 1) {
+            stop(paste0("Comparison '", cmp$name, "' uses compound groups (", paste(cmp$A, collapse = "+"), "-vs-", paste(cmp$B, collapse = "+"), "); only one group per side is supported"))
+        }
+        if (!cmp$A %in% condition_levels) {
+            stop(paste0("Comparison '", cmp$name, "' references unknown group '", cmp$A, "' (available: ", paste(condition_levels, collapse = ", "), ")"))
+        }
+        if (!cmp$B %in% condition_levels) {
+            stop(paste0("Comparison '", cmp$name, "' references unknown group '", cmp$B, "' (available: ", paste(condition_levels, collapse = ", "), ")"))
+        }
+        if (cmp$A == cmp$B) {
+            stop(paste0("Comparison '", cmp$name, "' compares group '", cmp$A, "' against itself"))
+        }
+    }
+    invisible(parsed)
+}
+
+## Select the samples of a pairwise contrast from the full annotation and count
+## tables. Samples are chosen via the metadata condition column (never by regex
+## on sample names) and ordered B then A; the count matrix is subset by the
+## ordered sample rownames so metadata and counts stay exactly aligned.
+select_contrast_samples <- function(sampleData_all, countData_all, A, B) {
+    if (length(A) != 1 || length(B) != 1) {
+        stop("select_contrast_samples requires exactly one group per side")
+    }
+    if (anyDuplicated(colnames(countData_all))) {
+        stop(paste0("Duplicate sample IDs in count table: ", paste(colnames(countData_all)[duplicated(colnames(countData_all))], collapse = ", ")))
+    }
+    sampleData <- droplevels(rbind(subset(sampleData_all, condition == B), subset(sampleData_all, condition == A)))
+    if (anyDuplicated(rownames(sampleData))) {
+        stop(paste0("Duplicate sample IDs in comparison: ", paste(rownames(sampleData)[duplicated(rownames(sampleData))], collapse = ", ")))
+    }
+    if (!all(rownames(sampleData) %in% colnames(countData_all))) {
+        stop("Count file does not correspond to the annotation file for this comparison")
+    }
+    countData <- countData_all[, rownames(sampleData), drop = FALSE]
+    list(sampleData = sampleData, countData = countData)
+}
+
+## Format a DESeq2 results object for export: add gene name and ID, select the
+## canonical column order by name and append genomic coordinates after Gene_ID.
+## Shrunk tables carry no stat column; raw (unshrunk) tables append stat last.
+format_deseq2_results <- function(res, gtf_gene, shrink = TRUE) {
+    res$Gene <- unlist(lapply(rownames(res), function(x) {
+        get_gene_name(x, gtf_gene)
+    }))
+    res$Gene_ID <- rownames(res)
+    if (shrink) {
+        res <- res[, c("Gene_ID", "Gene", "baseMean", "log2FoldChange", "lfcSE", "pvalue", "padj")]
+    } else {
+        res <- res[, c("Gene_ID", "Gene", "baseMean", "log2FoldChange", "lfcSE", "pvalue", "padj", "stat")]
+    }
+    add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+}
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index d55480d1..55660ae8 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -122,6 +122,7 @@ process run_deseq2{
 
     output:
     path "*_table*", emit: tbls
+    path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
     path "log", emit: log
@@ -227,7 +228,7 @@ workflow DE{
     featurecount_deseq(annofile.combine(mapsamples_ch.collate(1)))
     prepare_count_table(featurecount_deseq.out.fc_cts.collect())
     run_deseq2(prepare_count_table.out.counts, prepare_count_table.out.anno, annofile)
-    filter_significant(run_deseq2.out.tbls)
+    filter_significant(run_deseq2.out.result_tbls)
     create_summary_snippet(run_deseq2.out.tbls.concat(run_deseq2.out.figs.concat(run_deseq2.out.session)).collect())
     collect_deseq(filter_significant.out.sigtbls.collect())
 
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 0982f1a2..0b2c4042 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -87,8 +87,9 @@ rule filter_significant:
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DE', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc')
-    shell: "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc'),
+            bins = BINS
+    shell: "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
 
 rule create_summary_snippet:
     input:  rules.run_deseq2.output.pca,
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 080ffbf6..52d6620e 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -122,6 +122,7 @@ process run_edger{
 
     output:
     path "*_table*", emit: tbls
+    path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
     path "log", emit: log
@@ -228,7 +229,7 @@ workflow DE{
     featurecount_edger(annofile.combine(mapsamples_ch.collate(1)))
     prepare_count_table(featurecount_edger.out.fc_cts.collect())
     run_edger(prepare_count_table.out.counts, prepare_count_table.out.anno, annofile)
-    filter_significant(run_edger.out.tbls)
+    filter_significant(run_edger.out.result_tbls)
     create_summary_snippet(run_edger.out.tbls.concat(run_edger.out.figs.concat(run_edger.out.session)).collect())
     collect_edger(filter_significant.out.sigtbls.collect())
 

From 3bd1f4699d84fe6e5249cf5e1735f3ab44f44a45 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 10:32:10 +0200
Subject: [PATCH 61/80] Added new section PostDE to Analysis to automatically
 run GO/GSEA/GSVA analysis on selected cutoff output

---
 containers/apptainer/postde.def      |  24 ++
 envs/postde.yaml                     |  28 ++
 scripts/Analysis/DE/DESEQ2.R         |  33 +++
 scripts/Analysis/DE/EDGER.R          |  33 +++
 scripts/Analysis/PostDE/common.R     | 229 +++++++++++++++
 scripts/Analysis/PostDE/enrichment.R | 290 +++++++++++++++++++
 scripts/Analysis/PostDE/export.R     | 134 +++++++++
 scripts/Analysis/PostDE/regulatory.R | 406 +++++++++++++++++++++++++++
 scripts/Analysis/PostDE/run.R        | 199 +++++++++++++
 tests/postde_core.R                  | 323 +++++++++++++++++++++
 tests/test_postde_core.py            | 299 ++++++++++++++++++++
 11 files changed, 1998 insertions(+)
 create mode 100644 containers/apptainer/postde.def
 create mode 100644 envs/postde.yaml
 create mode 100644 scripts/Analysis/PostDE/common.R
 create mode 100644 scripts/Analysis/PostDE/enrichment.R
 create mode 100644 scripts/Analysis/PostDE/export.R
 create mode 100644 scripts/Analysis/PostDE/regulatory.R
 create mode 100644 scripts/Analysis/PostDE/run.R
 create mode 100644 tests/postde_core.R
 create mode 100644 tests/test_postde_core.py

diff --git a/containers/apptainer/postde.def b/containers/apptainer/postde.def
new file mode 100644
index 00000000..d84f9d70
--- /dev/null
+++ b/containers/apptainer/postde.def
@@ -0,0 +1,24 @@
+Bootstrap: docker
+From: continuumio/miniconda3
+
+%files
+    envs/postde.yaml /opt/envs/
+    scripts /opt/MONSDA/
+
+%environment
+
+%post
+    find /opt/MONSDA/scripts -type f \( -name '*.py' -o -name '*.R' -o -name '*.sh' -o -name '*.pl' \) -exec chmod a+x {} +
+    ls -alrt /opt/envs
+    chmod -R +x /opt/envs/postde.yaml
+
+    ENV_NAME=postde
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> $APPTAINER_ENVIRONMENT
+    echo "conda activate $ENV_NAME" >> $APPTAINER_ENVIRONMENT
+
+    . /opt/conda/etc/profile.d/conda.sh
+    conda env create -f /opt/envs/postde.yaml -p /opt/conda/envs/$ENV_NAME
+    conda clean --all
+
+%runscript
+    exec "$@"
diff --git a/envs/postde.yaml b/envs/postde.yaml
new file mode 100644
index 00000000..f3e1408d
--- /dev/null
+++ b/envs/postde.yaml
@@ -0,0 +1,28 @@
+name: postde
+channels:
+  - conda-forge
+  - bioconda
+  - nodefaults
+dependencies:
+  - r-base=4.5.3
+  - r-jsonlite=2.0.0
+  - r-gprofiler2=0.2.4
+  - bioconductor-clusterprofiler=4.18.4
+  - bioconductor-deseq2=1.50.2
+  - bioconductor-decoupler=2.16.0
+  - bioconductor-edger=4.8.2
+  - bioconductor-fgsea=1.36.2
+  - bioconductor-glimma=2.20.0
+  - bioconductor-go.db=3.22.0
+  - bioconductor-gsva=2.4.9
+  - bioconductor-limma=3.66.0
+  - bioconductor-variancepartition=1.40.2
+  - bioconductor-biocparallel=1.44.0
+  - r-plotly=4.12.1
+  - r-htmlwidgets=1.6.4
+  - r-shiny=1.14.0
+  - r-dt=0.34.0
+  - r-rmarkdown=2.32
+  - r-knitr=1.52
+  - r-lme4=2.0_6
+  - quarto=1.9.38
diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 96a1699e..45cf78e4 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -32,8 +32,31 @@ print(args)
 
 ## FUNCS
 libp <- paste0(gsub("/bin/conda", "/envs/monsda", Sys.getenv("CONDA_EXE")), "/share/MONSDA/scripts/lib/_lib.R")
+if (!file.exists(libp)) {
+    postde_args <- commandArgs(trailingOnly = FALSE)
+    postde_file <- sub("^--file=", "", postde_args[grep("^--file=", postde_args)])
+    if (length(postde_file) == 0) {
+        stop("Rscript --file path not found in commandArgs")
+    }
+    libp <- file.path(dirname(normalizePath(postde_file)), "..", "..", "lib", "_lib.R")
+}
 source(libp)
 
+postde_enabled <- Sys.getenv("MONSDA_POSTDE") == "1"
+if (postde_enabled) {
+    postde_args <- commandArgs(trailingOnly = FALSE)
+    postde_file <- sub("^--file=", "", postde_args[grep("^--file=", postde_args)])
+    if (length(postde_file) == 0) {
+        stop("MONSDA_POSTDE=1 but Rscript --file path not found in commandArgs")
+    }
+    postde_lib <- file.path(dirname(normalizePath(postde_file)), "..", "PostDE", "export.R")
+    if (!file.exists(postde_lib)) {
+        stop(paste0("MONSDA_POSTDE=1 but export.R not found at ", postde_lib))
+    }
+    source(postde_lib)
+    postde_bundles <- list()
+}
+
 ## set thread-usage
 BPPARAM <- MulticoreParam(workers = availablecores)
 
@@ -306,6 +329,9 @@ for (contrast in comparison) {
         res_shrink <- lfcShrink(dds = dds, coef = paste("condition", A, "vs", B, sep = "_"), res = res, type = "apeglm")
 
         # add comp object to list for image
+        if (postde_enabled) {
+            postde_capture(engine = "deseq2", id = contrast_name, A = A, B = B, normalized = FALSE, metadata = sampleData, counts = countData, expression = assay(vsd), formula = design, results = postde_results_deseq2(res), mean_scale = "baseMean")
+        }
         comparison_objs[[contrast_name]] <- res
 
         # sort and output
@@ -373,6 +399,9 @@ for (contrast in comparison) {
 
             # add comp object to list for image
             listname <- paste(contrast_name, "_norm", sep = "")
+            if (postde_enabled) {
+                postde_capture(engine = "deseq2", id = listname, A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = as.matrix(counts(counts_norm)), expression = assay(vsd_norm), formula = design_norm, results = postde_results_deseq2(res), mean_scale = "baseMean")
+            }
             comparison_objs[[listname]] <- res
 
             # sort and output
@@ -438,4 +467,8 @@ for (contrast in comparison) {
 
 ##############################
 
+if (postde_enabled) {
+    postde_write(outdir, combi, "deseq2")
+}
+
 save.image(file = paste("DE", "DESEQ2", combi, "SESSION.gz", sep = "_"), version = NULL, ascii = FALSE, compress = "gzip", safe = TRUE)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index b17558e1..2fa63ce1 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -27,8 +27,31 @@ print(args)
 
 ## FUNCS
 libp <- paste0(gsub("/bin/conda", "/envs/monsda", Sys.getenv("CONDA_EXE")), "/share/MONSDA/scripts/lib/_lib.R")
+if (!file.exists(libp)) {
+    postde_args <- commandArgs(trailingOnly = FALSE)
+    postde_file <- sub("^--file=", "", postde_args[grep("^--file=", postde_args)])
+    if (length(postde_file) == 0) {
+        stop("Rscript --file path not found in commandArgs")
+    }
+    libp <- file.path(dirname(normalizePath(postde_file)), "..", "..", "lib", "_lib.R")
+}
 source(libp)
 
+postde_enabled <- Sys.getenv("MONSDA_POSTDE") == "1"
+if (postde_enabled) {
+    postde_args <- commandArgs(trailingOnly = FALSE)
+    postde_file <- sub("^--file=", "", postde_args[grep("^--file=", postde_args)])
+    if (length(postde_file) == 0) {
+        stop("MONSDA_POSTDE=1 but Rscript --file path not found in commandArgs")
+    }
+    postde_lib <- file.path(dirname(normalizePath(postde_file)), "..", "PostDE", "export.R")
+    if (!file.exists(postde_lib)) {
+        stop(paste0("MONSDA_POSTDE=1 but export.R not found at ", postde_lib))
+    }
+    source(postde_lib)
+    postde_bundles <- list()
+}
+
 ## plotMDS needs at least 3 samples/columns, fall back to a placeholder plot otherwise
 safe_plotMDS <- function(dgeobj, ...) {
     if (ncol(dgeobj) < 3) {
@@ -370,6 +393,9 @@ for (contrast in comparison) {
             qlf <- glmQLFTest(fit, contrast = AvsB) ## glm quasi-likelihood-F-Test
         }
         # add comp object to list for image
+        if (postde_enabled) {
+            postde_capture(engine = "edger", id = contrast_name, A = A, B = B, normalized = FALSE, metadata = sampleData, counts = countData, expression = cpm(dge, log = TRUE), formula = des, results = postde_results_edger(qlf), mean_scale = "logCPM")
+        }
         comparison_objs[[contrast_name]] <- qlf
 
         # # Add gene names  (check how gene_id col is named )
@@ -459,6 +485,9 @@ for (contrast in comparison) {
             AvsB[contrast_col] <- 1
             qlf <- glmQLFTest(fit_norm, contrast = AvsB) ## glm quasi-likelihood-F-Test
             # add comp object to list for image
+            if (postde_enabled) {
+                postde_capture(engine = "edger", id = paste0(contrast_name, "_norm"), A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = as.matrix(counts(counts_norm)), expression = cpm(dge_norm, log = TRUE), formula = des_norm, results = postde_results_edger(qlf), mean_scale = "logCPM")
+            }
             comparison_objs <- append(comparison_objs, qlf)
 
             # # Add gene names  (check how gene_id col is named )
@@ -529,4 +558,8 @@ for (contrast in comparison) {
 }
 
 
+if (postde_enabled) {
+    postde_write(outdir, combi, "edger")
+}
+
 save.image(file = paste("DE_EDGER", combi, "SESSION.gz", sep = "_"), version = NULL, ascii = FALSE, compress = "gzip", safe = TRUE)
diff --git a/scripts/Analysis/PostDE/common.R b/scripts/Analysis/PostDE/common.R
new file mode 100644
index 00000000..13652eb7
--- /dev/null
+++ b/scripts/Analysis/PostDE/common.R
@@ -0,0 +1,229 @@
+postde_validate_design <- function(design, contrast) {
+    design <- as.matrix(design)
+    if (nrow(design) < 2) {
+        stop("design has fewer than 2 rows")
+    }
+    if (any(!is.finite(design))) {
+        stop("design contains non-finite values")
+    }
+    if (is.null(colnames(design))) {
+        stop("design has no column names")
+    }
+    if (is.null(names(contrast))) {
+        contrast <- as.numeric(contrast)
+    } else {
+        if (!all(names(contrast) %in% colnames(design))) {
+            stop(paste0("contrast names do not match design columns: ", paste(setdiff(names(contrast), colnames(design)), collapse = ", ")))
+        }
+        contrast <- as.numeric(contrast[colnames(design)])
+    }
+    if (length(contrast) != ncol(design)) {
+        stop(paste0("contrast length (", length(contrast), ") does not match design columns (", ncol(design), ")"))
+    }
+    if (any(!is.finite(contrast))) {
+        stop("contrast contains non-finite values")
+    }
+    if (all(contrast == 0)) {
+        stop("contrast is all zero")
+    }
+    const_cols <- apply(design, 2, function(x) length(unique(x)) == 1)
+    if (any(const_cols & contrast != 0)) {
+        stop(paste0("contrast has nonzero coefficient on constant design column(s): ", paste(colnames(design)[const_cols & contrast != 0], collapse = ", ")))
+    }
+    r <- qr(design)$rank
+    if (r < ncol(design)) {
+        stop(paste0("design is not full rank (rank ", r, " < ", ncol(design), " columns)"))
+    }
+    if (nrow(design) - r <= 0) {
+        stop("design has no residual degrees of freedom")
+    }
+    a <- design %*% solve(crossprod(design)) %*% contrast
+    fitted <- crossprod(design, a)
+    if (max(abs(fitted - contrast)) > 1e-8) {
+        stop("contrast is not estimable from the design")
+    }
+    invisible(TRUE)
+}
+
+postde_contrast <- function(formula, metadata, A, B) {
+    md <- as.data.frame(metadata)
+    if (!"condition" %in% colnames(md)) {
+        stop("postde_contrast: metadata has no condition column")
+    }
+    md$condition <- relevel(md$condition, ref = B)
+    mdA <- md
+    mdB <- md
+    mdA$condition <- factor(rep(A, nrow(md)), levels = levels(md$condition))
+    mdB$condition <- factor(rep(B, nrow(md)), levels = levels(md$condition))
+    mA <- model.matrix(formula, data = mdA)
+    mB <- model.matrix(formula, data = mdB)
+    setNames(colMeans(mA) - colMeans(mB), colnames(mA))
+}
+
+postde_rank_genes <- function(results, stat_col = "stat") {
+    if (!is.data.frame(results)) {
+        results <- as.data.frame(results)
+    }
+    if (!"gene_id" %in% colnames(results)) {
+        stop("results must contain a gene_id column")
+    }
+    if (!stat_col %in% colnames(results)) {
+        stop(paste0("results must contain a ", stat_col, " column"))
+    }
+    if (any(is.na(results$gene_id)) || any(!nzchar(as.character(results$gene_id)))) {
+        stop("results contain empty or NA gene ids")
+    }
+    if (anyDuplicated(results$gene_id)) {
+        stop("results contain duplicate gene ids")
+    }
+    if (!is.numeric(results[[stat_col]])) {
+        stop(paste0(stat_col, " column must be numeric"))
+    }
+    if (any(!is.finite(results[[stat_col]]))) {
+        results <- results[is.finite(results[[stat_col]]), , drop = FALSE]
+    }
+    if (nrow(results) == 0) {
+        stop("results contain no genes with finite ", stat_col)
+    }
+    results <- results[order(-results[[stat_col]], results$gene_id), , drop = FALSE]
+    results$rank <- seq_len(nrow(results))
+    results
+}
+
+postde_ora_universe <- function(results, custom = NULL) {
+    if (!is.data.frame(results)) {
+        results <- as.data.frame(results)
+    }
+    if (!"gene_id" %in% colnames(results)) {
+        stop("results must contain a gene_id column")
+    }
+    if (!"pvalue" %in% colnames(results)) {
+        stop("results must contain a pvalue column")
+    }
+    if (any(is.na(results$gene_id)) || any(!nzchar(as.character(results$gene_id)))) {
+        stop("results contain empty or NA gene ids")
+    }
+    tested <- results$gene_id[is.finite(results$pvalue)]
+    if (is.null(custom)) {
+        unique(tested)
+    } else {
+        unique(intersect(custom, tested))
+    }
+}
+
+postde_significant <- function(results, direction = "all", padj = 0.05, lfc = 1) {
+    if (!is.data.frame(results)) {
+        results <- as.data.frame(results)
+    }
+    if (!all(c("gene_id", "logFC", "pvalue", "padj") %in% colnames(results))) {
+        stop("results must contain gene_id, logFC, pvalue and padj columns")
+    }
+    if (any(is.na(results$gene_id)) || any(!nzchar(as.character(results$gene_id)))) {
+        stop("results contain empty or NA gene ids")
+    }
+    sig <- is.finite(results$padj) & results$padj < padj
+    if (direction == "up") {
+        sig <- sig & results$logFC >= lfc
+    } else if (direction == "down") {
+        sig <- sig & results$logFC <= -lfc
+    } else if (direction == "all") {
+        sig <- sig & abs(results$logFC) >= lfc
+    } else {
+        stop(paste0("unknown direction '", direction, "' (use all, up or down)"))
+    }
+    sig[is.na(sig)] <- FALSE
+    results$gene_id[sig]
+}
+
+postde_write_empty <- function(path, status, header = c("gene_id", "logFC", "pvalue", "padj", "stat", "mean")) {
+    con <- file(path, open = "wt")
+    writeLines(paste(header, collapse = "\t"), con)
+    close(con)
+    status_path <- paste0(path, ".status.json")
+    esc <- gsub("([\"\\\\])", "\\\\\\1", status)
+    writeLines(paste0('{"status": "', esc, '"}'), status_path)
+    invisible(status)
+}
+
+postde_read_tsv <- function(path, header = TRUE, ...) {
+    if (!file.exists(path)) {
+        stop(paste0("file not found: ", path))
+    }
+    read.delim(path, header = header, stringsAsFactors = FALSE, check.names = FALSE, ...)
+}
+
+postde_sanitize_id <- function(id) {
+    if (is.null(id) || length(id) != 1 || is.na(id) || !nzchar(id)) {
+        stop("postde_sanitize_id: id must be a single non-empty string")
+    }
+    if (id == "." || id == "..") {
+        stop(paste0("postde_sanitize_id: unsafe id '", id, "'"))
+    }
+    gsub("[^A-Za-z0-9._-]", "_", id)
+}
+
+postde_check_sanitized_ids <- function(ids) {
+    san <- vapply(ids, postde_sanitize_id, character(1))
+    if (anyDuplicated(san)) {
+        stop(paste0("postde: duplicate sanitized entry ids: ", paste(unique(san[duplicated(san)]), collapse = ", ")))
+    }
+    invisible(san)
+}
+
+postde_differential_scores <- function(scores, design, contrast) {
+    if (!requireNamespace("limma", quietly = TRUE)) {
+        stop("limma is required for differential scores but is not installed")
+    }
+    scores <- as.matrix(scores)
+    design <- as.matrix(design)
+    postde_validate_design(design, contrast)
+    if (ncol(scores) != nrow(design)) {
+        stop(paste0("scores columns (", ncol(scores), ") do not match design rows (", nrow(design), ")"))
+    }
+    if (!is.null(colnames(scores)) && !is.null(rownames(design)) && !identical(colnames(scores), rownames(design))) {
+        stop("scores column names do not match design row names")
+    }
+    if (nrow(scores) == 0) {
+        stop("scores has no features")
+    }
+    if (any(!is.finite(scores))) {
+        stop("scores contains non-finite values")
+    }
+    fit <- limma::lmFit(scores, design)
+    fit2 <- limma::contrasts.fit(fit, contrast)
+    fit2 <- limma::eBayes(fit2)
+    tt <- limma::topTable(fit2, number = nrow(scores), sort.by = "none")
+    se <- fit2$stdev.unscaled[, 1] * fit2$sigma
+    list(
+        results = data.frame(
+            feature_id = rownames(scores),
+            score_difference = tt$logFC,
+            pvalue = tt$P.Value,
+            padj = tt$adj.P.Val,
+            stat = tt$t,
+            mean_score = tt$AveExpr,
+            SE = se,
+            stringsAsFactors = FALSE
+        ),
+        design = design,
+        contrast = contrast
+    )
+}
+
+postde_gsva_scores <- function(expr, gene_sets, method = "gsva", min_size = 10, max_size = 500) {
+    if (!requireNamespace("GSVA", quietly = TRUE)) {
+        stop("GSVA is required for gsva scores but is not installed")
+    }
+    if (!requireNamespace("BiocParallel", quietly = TRUE)) {
+        stop("BiocParallel is required for gsva scores but is not installed")
+    }
+    expr <- as.matrix(expr)
+    if (method == "gsva") {
+        param <- GSVA::gsvaParam(exprData = expr, geneSets = gene_sets, minSize = min_size, maxSize = max_size, kcdf = "Gaussian")
+    } else if (method == "ssgsea") {
+        param <- GSVA::ssgseaParam(exprData = expr, geneSets = gene_sets, minSize = min_size, maxSize = max_size)
+    } else {
+        stop(paste0("unknown GSVA method '", method, "' (use gsva or ssgsea)"))
+    }
+    GSVA::gsva(param, BPPARAM = BiocParallel::SerialParam())
+}
diff --git a/scripts/Analysis/PostDE/enrichment.R b/scripts/Analysis/PostDE/enrichment.R
new file mode 100644
index 00000000..db923800
--- /dev/null
+++ b/scripts/Analysis/PostDE/enrichment.R
@@ -0,0 +1,290 @@
+postde_read_term2gene <- function(path) {
+    df <- postde_read_tsv(path, header = TRUE)
+    if (!identical(sort(colnames(df)), c("gene", "term"))) {
+        stop("term2gene must have exactly columns 'term' and 'gene'")
+    }
+    df <- df[, c("term", "gene")]
+    df$term <- as.character(df$term)
+    df$gene <- as.character(df$gene)
+    if (any(is.na(df$term)) || any(!nzchar(df$term)) || any(is.na(df$gene)) || any(!nzchar(df$gene))) {
+        stop("term2gene contains empty or NA ids")
+    }
+    df <- df[!duplicated(df), , drop = FALSE]
+    df
+}
+
+postde_read_term2name <- function(path) {
+    df <- postde_read_tsv(path, header = TRUE)
+    if (!identical(sort(colnames(df)), c("name", "term"))) {
+        stop("term2name must have exactly columns 'term' and 'name'")
+    }
+    df <- df[, c("term", "name")]
+    df$term <- as.character(df$term)
+    df$name <- as.character(df$name)
+    if (any(is.na(df$term)) || any(!nzchar(df$term)) || any(is.na(df$name)) || any(!nzchar(df$name))) {
+        stop("term2name contains empty or NA ids")
+    }
+    df <- df[!duplicated(df), , drop = FALSE]
+    n_names <- tapply(df$name, df$term, function(x) length(unique(x)))
+    bad <- names(n_names)[n_names > 1]
+    if (length(bad) > 0) {
+        stop(paste0("term2name has multiple distinct names for term ids: ", paste(bad, collapse = ", ")))
+    }
+    df
+}
+
+postde_build_gomap <- function(term2gene) {
+    if (!requireNamespace("clusterProfiler", quietly = TRUE)) {
+        stop("clusterProfiler is required for go_expand but is not installed")
+    }
+    if (!requireNamespace("GO.db", quietly = TRUE)) {
+        stop("GO.db is required for go_expand but is not installed")
+    }
+    if (!all(c("term", "gene") %in% colnames(term2gene))) {
+        stop("term2gene must have columns 'term' and 'gene'")
+    }
+    term2gene <- term2gene[!duplicated(term2gene), , drop = FALSE]
+    known <- ls(GO.db::GOTERM)
+    unknown <- setdiff(unique(as.character(term2gene$term)), known)
+    if (length(unknown) > 0) {
+        stop(paste0("term2gene contains unknown GO terms: ", paste(head(unknown, 5), collapse = ", ")))
+    }
+    clusterProfiler::buildGOmap(term2gene)
+}
+
+postde_flatten_list_cols <- function(df) {
+    for (col in colnames(df)) {
+        if (is.list(df[[col]])) {
+            df[[col]] <- vapply(df[[col]], function(x) paste(unlist(x), collapse = ";"), character(1))
+        }
+    }
+    df
+}
+
+postde_run_gprofiler <- function(entry, config, outdir, gost_fun = NULL) {
+    if (!requireNamespace("gprofiler2", quietly = TRUE)) {
+        stop("gprofiler enabled but package gprofiler2 is not installed")
+    }
+    if (is.null(gost_fun)) {
+        gost_fun <- gprofiler2::gost
+    }
+    gp <- config$gprofiler
+    if (is.null(gp$organism) || !nzchar(gp$organism)) {
+        stop("gprofiler: organism must be set explicitly (no default)")
+    }
+    organism <- gp$organism
+    domain_scope <- if (is.null(gp$domain_scope)) "custom" else gp$domain_scope
+    if (!domain_scope %in% c("annotated", "known", "custom", "custom_annotated")) {
+        stop(paste0("gprofiler: invalid domain_scope '", domain_scope, "' (use annotated, known, custom or custom_annotated)"))
+    }
+    if (!isTRUE(gp$allow_network)) {
+        stop("gprofiler: gost is an online call and requires gprofiler.allow_network=true")
+    }
+    sources <- unlist(gp$sources)
+    if (length(sources) == 0) {
+        sources <- NULL
+    }
+    correction_method <- if (is.null(gp$correction_method)) "g_SCS" else gp$correction_method
+    if (!correction_method %in% c("g_SCS", "bonferroni", "fdr", "false_discovery_rate", "gSCS", "analytical")) {
+        stop(paste0("gprofiler: invalid correction_method '", correction_method, "'"))
+    }
+    universe <- postde_ora_universe(entry$results)
+    custom_bg <- universe
+    if (!is.null(gp$background)) {
+        bg <- postde_read_tsv(gp$background, header = FALSE)[[1]]
+        custom_bg <- intersect(bg, universe)
+        if (length(custom_bg) == 0) {
+            stop("gprofiler: background does not intersect the tested universe")
+        }
+    }
+    padj <- config$padj
+    lfc <- config$lfc
+    out <- list()
+    for (direction in c("all", "up", "down")) {
+        query <- postde_significant(entry$results, direction = direction, padj = padj, lfc = lfc)
+        res_file <- file.path(outdir, paste0("gprofiler_", direction, "_result.tsv"))
+        meta_file <- file.path(outdir, paste0("gprofiler_", direction, "_meta.rds"))
+        query_file <- file.path(outdir, paste0("gprofiler_", direction, "_query.rds"))
+        if (length(query) == 0) {
+            postde_write_empty(res_file, "no significant genes")
+            out[[direction]] <- list(status = "no significant genes", result = res_file)
+            next
+        }
+        if (length(intersect(query, custom_bg)) == 0) {
+            stop(paste0("gprofiler: query for direction '", direction, "' is disjoint from the background"))
+        }
+        saveRDS(list(query = query, universe = custom_bg), query_file)
+        gost_args <- list(
+            query = query,
+            organism = organism,
+            domain_scope = domain_scope,
+            sources = sources,
+            significant = FALSE,
+            user_threshold = padj,
+            correction_method = correction_method
+        )
+        if (domain_scope %in% c("custom", "custom_annotated")) {
+            gost_args$custom_bg <- custom_bg
+        }
+        gost_res <- tryCatch(
+            do.call(gost_fun, gost_args),
+            error = function(e) {
+                stop(paste0("gprofiler: gost call failed for direction '", direction, "': ", conditionMessage(e)))
+            }
+        )
+        if (is.null(gost_res) || is.null(gost_res$result)) {
+            postde_write_empty(res_file, "no enriched terms")
+            out[[direction]] <- list(status = "no enriched terms", result = res_file)
+            next
+        }
+        res_df <- postde_flatten_list_cols(as.data.frame(gost_res$result))
+        write.table(res_df, res_file, sep = "\t", row.names = FALSE, quote = FALSE)
+        saveRDS(gost_res$meta, meta_file)
+        saveRDS(gost_res$result, file.path(outdir, paste0("gprofiler_", direction, "_raw.rds")))
+        out[[direction]] <- list(status = "ok", result = res_file, meta = meta_file, query = query_file, raw = file.path(outdir, paste0("gprofiler_", direction, "_raw.rds")))
+    }
+    out
+}
+
+postde_run_enricher <- function(genes, universe, term2gene, term2name, min_size, max_size, outdir, direction) {
+    if (!requireNamespace("clusterProfiler", quietly = TRUE)) {
+        stop("clusterprofiler enabled but package clusterProfiler is not installed")
+    }
+    res_file <- file.path(outdir, paste0("enricher_", direction, "_result.tsv"))
+    header <- c("ID", "Description", "GeneRatio", "BgRatio", "pvalue", "p.adjust", "qvalue", "geneID", "Count")
+    if (length(genes) == 0) {
+        postde_write_empty(res_file, "no significant genes", header = header)
+        return(list(status = "no significant genes", result = res_file))
+    }
+    if (anyDuplicated(genes)) {
+        stop("significant gene list contains duplicate ids")
+    }
+    if (length(intersect(genes, term2gene$gene)) == 0) {
+        stop("no overlap between significant genes and term2gene genes")
+    }
+    enr_args <- list(gene = genes, universe = universe, TERM2GENE = term2gene, pvalueCutoff = 1, qvalueCutoff = 1, minGSSize = min_size, maxGSSize = max_size)
+    if (is.null(term2name)) {
+        enr_args$TERM2NAME <- NA
+    } else {
+        enr_args$TERM2NAME <- term2name
+    }
+    enr <- do.call(clusterProfiler::enricher, enr_args)
+    res <- as.data.frame(enr)
+    if (nrow(res) == 0) {
+        postde_write_empty(res_file, "no enriched terms", header = header)
+        return(list(status = "no enriched terms", result = res_file))
+    }
+    write.table(res, res_file, sep = "\t", row.names = FALSE, quote = FALSE)
+    list(status = "ok", result = res_file)
+}
+
+postde_run_gsea <- function(entry, term2gene, term2name, min_size, max_size, seed, outdir) {
+    if (!requireNamespace("clusterProfiler", quietly = TRUE)) {
+        stop("clusterprofiler enabled but package clusterProfiler is not installed")
+    }
+    res_file <- file.path(outdir, "gsea_result.tsv")
+    header <- c("ID", "Description", "setSize", "enrichmentScore", "NES", "pvalue", "p.adjust", "qvalues", "rank", "leading_edge", "core_enrichment")
+    if (!"stat" %in% colnames(entry$results)) {
+        postde_write_empty(res_file, "rank unavailable: results have no stat column", header = header)
+        return(list(status = "rank unavailable", result = res_file))
+    }
+    ranked <- postde_rank_genes(entry$results, stat_col = "stat")
+    gene_list <- setNames(ranked$stat, ranked$gene_id)
+    saveRDS(gene_list, file.path(outdir, "gsea_ranked.rds"))
+    if (length(intersect(names(gene_list), term2gene$gene)) == 0) {
+        stop("no overlap between ranked genes and term2gene genes")
+    }
+    gsea_args <- list(geneList = gene_list, TERM2GENE = term2gene, seed = seed, pvalueCutoff = 1, minGSSize = min_size, maxGSSize = max_size)
+    if (is.null(term2name)) {
+        gsea_args$TERM2NAME <- NA
+    } else {
+        gsea_args$TERM2NAME <- term2name
+    }
+    if ("by" %in% names(formals(clusterProfiler::GSEA))) {
+        gsea_args$by <- "fgsea"
+    } else {
+        gsea_args$method <- "fgsea"
+    }
+    gsea_res <- do.call(clusterProfiler::GSEA, gsea_args)
+    res <- as.data.frame(gsea_res)
+    if (nrow(res) == 0) {
+        postde_write_empty(res_file, "no enriched terms", header = header)
+        return(list(status = "no enriched terms", result = res_file))
+    }
+    write.table(res, res_file, sep = "\t", row.names = FALSE, quote = FALSE)
+    list(status = "ok", result = res_file, ranked = file.path(outdir, "gsea_ranked.rds"))
+}
+
+postde_run_gsva <- function(entry, term2gene, term2name, config, outdir) {
+    if (!requireNamespace("GSVA", quietly = TRUE)) {
+        stop("gsva enabled but package GSVA is not installed")
+    }
+    gs <- config$gsva
+    method <- if (is.null(gs$method)) "gsva" else gs$method
+    min_size <- if (is.null(gs$min_size)) config$min_size else gs$min_size
+    max_size <- if (is.null(gs$max_size)) config$max_size else gs$max_size
+    gene_sets <- split(term2gene$gene, term2gene$term)
+    saveRDS(gene_sets, file.path(outdir, "gsva_sets.rds"))
+    saveRDS(list(term2gene = term2gene, term2name = term2name, cohort = entry$id), file.path(outdir, "gsva_provenance.rds"))
+    scores <- postde_gsva_scores(entry$expression, gene_sets, method = method, min_size = min_size, max_size = max_size)
+    write.table(scores, file.path(outdir, "gsva_scores.tsv"), sep = "\t", col.names = NA, quote = FALSE)
+    diff <- postde_differential_scores(scores, entry$design, entry$contrast)
+    write.table(diff$results, file.path(outdir, "gsva_differential.tsv"), sep = "\t", row.names = FALSE, quote = FALSE)
+    write.table(diff$design, file.path(outdir, "gsva_design.tsv"), sep = "\t", col.names = NA, quote = FALSE)
+    write.table(data.frame(term = names(diff$contrast), coefficient = diff$contrast), file.path(outdir, "gsva_contrast.tsv"), sep = "\t", row.names = FALSE, quote = FALSE)
+    list(status = "ok", scores = file.path(outdir, "gsva_scores.tsv"), differential = file.path(outdir, "gsva_differential.tsv"))
+}
+
+postde_run_enrichment <- function(entry, config, outdir) {
+    cp <- config$clusterprofiler
+    gs <- config$gsva
+    cp_enabled <- is.list(cp) && isTRUE(cp$enabled)
+    gs_enabled <- is.list(gs) && isTRUE(gs$enabled)
+    if (!cp_enabled && !gs_enabled) {
+        return(list())
+    }
+    term2gene <- NULL
+    term2name <- NULL
+    if (cp_enabled || gs_enabled) {
+        if (is.null(cp$term2gene)) {
+            stop("term2gene path missing (clusterprofiler.term2gene required for clusterprofiler/gsva)")
+        }
+        term2gene <- postde_read_term2gene(cp$term2gene)
+        if (!is.null(cp$term2name)) {
+            term2name <- postde_read_term2name(cp$term2name)
+        }
+        if (isTRUE(cp$go_expand)) {
+            term2gene <- postde_build_gomap(term2gene)
+        }
+    }
+    universe <- postde_ora_universe(entry$results)
+    if (!is.null(cp$background)) {
+        bg <- postde_read_tsv(cp$background, header = FALSE)[[1]]
+        universe <- intersect(bg, universe)
+        if (length(universe) == 0) {
+            stop("clusterprofiler: background does not intersect the tested universe")
+        }
+    }
+    out <- list()
+    if (cp_enabled) {
+        ranked <- postde_rank_genes(entry$results, stat_col = "stat")
+        provenance <- list(
+            term2gene = term2gene,
+            term2name = term2name,
+            universe = universe,
+            ranked = ranked,
+            checksum = if (file.exists(cp$term2gene)) unname(tools::md5sum(cp$term2gene)) else NA_character_,
+            config = cp
+        )
+        saveRDS(provenance, file.path(outdir, "enrichment_provenance.rds"))
+        for (direction in c("all", "up", "down")) {
+            genes <- postde_significant(entry$results, direction = direction, padj = config$padj, lfc = config$lfc)
+            out[[paste0("enricher_", direction)]] <- postde_run_enricher(genes, universe, term2gene, term2name, config$min_size, config$max_size, outdir, direction)
+        }
+        out$gsea <- postde_run_gsea(entry, term2gene, term2name, config$min_size, config$max_size, config$seed, outdir)
+    }
+    if (gs_enabled) {
+        out$gsva <- postde_run_gsva(entry, term2gene, term2name, config, outdir)
+    }
+    out
+}
diff --git a/scripts/Analysis/PostDE/export.R b/scripts/Analysis/PostDE/export.R
new file mode 100644
index 00000000..26ea063f
--- /dev/null
+++ b/scripts/Analysis/PostDE/export.R
@@ -0,0 +1,134 @@
+postde_common_path <- function() {
+    frames <- sys.frames()
+    for (fr in frames) {
+        if (exists("postde_lib", envir = fr, inherits = FALSE)) {
+            return(file.path(dirname(get("postde_lib", envir = fr)), "common.R"))
+        }
+    }
+    NULL
+}
+
+postde_common <- postde_common_path()
+if (!is.null(postde_common) && file.exists(postde_common)) {
+    source(postde_common)
+} else {
+    postde_contrast <- function(formula, metadata, A, B) {
+        md <- as.data.frame(metadata)
+        if (!"condition" %in% colnames(md)) {
+            stop("postde_contrast: metadata has no condition column")
+        }
+        md$condition <- relevel(md$condition, ref = B)
+        mdA <- md
+        mdB <- md
+        mdA$condition <- factor(rep(A, nrow(md)), levels = levels(md$condition))
+        mdB$condition <- factor(rep(B, nrow(md)), levels = levels(md$condition))
+        mA <- model.matrix(formula, data = mdA)
+        mB <- model.matrix(formula, data = mdB)
+        setNames(colMeans(mA) - colMeans(mB), colnames(mA))
+    }
+}
+
+postde_bundles <- list()
+
+postde_results_deseq2 <- function(res) {
+    out <- data.frame(
+        gene_id = rownames(res),
+        logFC = as.numeric(res$log2FoldChange),
+        pvalue = as.numeric(res$pvalue),
+        padj = as.numeric(res$padj),
+        stat = as.numeric(res$stat),
+        mean = as.numeric(res$baseMean),
+        stringsAsFactors = FALSE
+    )
+    rownames(out) <- rownames(res)
+    out
+}
+
+postde_results_edger <- function(qlf) {
+    F <- qlf$table$F
+    if (any(is.finite(F) & F < 0)) {
+        stop("postde_results_edger: negative F statistics found")
+    }
+    df_test <- if (!is.null(qlf$df.test)) qlf$df.test else 1
+    one_df <- isTRUE(all(df_test == 1))
+    stat <- ifelse(is.finite(F) & F >= 0 & one_df, sign(qlf$table$logFC) * sqrt(F), NA_real_)
+    out <- data.frame(
+        gene_id = rownames(qlf$table),
+        logFC = as.numeric(qlf$table$logFC),
+        pvalue = as.numeric(qlf$table$PValue),
+        padj = p.adjust(qlf$table$PValue, method = "BH"),
+        stat = stat,
+        mean = as.numeric(qlf$table$logCPM),
+        stringsAsFactors = FALSE
+    )
+    rownames(out) <- rownames(qlf$table)
+    out
+}
+
+postde_capture <- function(engine, id, A, B, normalized, metadata, counts, expression, formula, results, mean_scale, library_normalized = TRUE) {
+    metadata <- as.data.frame(metadata)
+    counts <- as.matrix(counts)
+    expression <- as.matrix(expression)
+    results <- as.data.frame(results)
+    if (is.null(rownames(results)) || is.null(rownames(expression))) {
+        stop(paste0("postde: results and expression must have rownames for entry '", id, "'"))
+    }
+    if (!identical(rownames(results), rownames(expression))) {
+        stop(paste0("postde: results rownames do not match expression rownames for entry '", id, "'"))
+    }
+    if (anyDuplicated(rownames(results))) {
+        stop(paste0("postde: results contain duplicate gene ids for entry '", id, "'"))
+    }
+    if (!identical(rownames(metadata), colnames(counts))) {
+        stop(paste0("postde: metadata rownames do not match counts colnames for entry '", id, "'"))
+    }
+    if (!identical(colnames(counts), colnames(expression))) {
+        stop(paste0("postde: counts colnames do not match expression colnames for entry '", id, "'"))
+    }
+    if (!all(rownames(results) %in% rownames(counts))) {
+        stop(paste0("postde: results contain genes absent from counts for entry '", id, "'"))
+    }
+    if (!all(rownames(results) == results$gene_id)) {
+        stop(paste0("postde: results rownames do not match gene_id column for entry '", id, "'"))
+    }
+    md <- metadata
+    md$condition <- relevel(md$condition, ref = B)
+    design <- model.matrix(formula, data = md)
+    contrast <- postde_contrast(formula, metadata, A, B)
+    postde_validate_design(design, contrast)
+    entry <- list(
+        id = id,
+        A = A,
+        B = B,
+        normalized = isTRUE(normalized),
+        library_normalized = isTRUE(library_normalized),
+        metadata = metadata,
+        counts = counts,
+        expression = expression,
+        design = design,
+        contrast = contrast,
+        results = results,
+        mean_scale = mean_scale
+    )
+    postde_bundles[[length(postde_bundles) + 1L]] <<- entry
+    invisible(entry)
+}
+
+postde_write <- function(outdir, combi, engine) {
+    if (length(postde_bundles) == 0L) {
+        stop("MONSDA_POSTDE=1 but no contrast entries were captured; refusing to write an empty bundle")
+    }
+    ids <- vapply(postde_bundles, function(e) e$id, character(1))
+    if (anyDuplicated(ids)) {
+        stop(paste0("postde: duplicate entry ids: ", paste(ids[duplicated(ids)], collapse = ", ")))
+    }
+    postde_check_sanitized_ids(ids)
+    bundle <- list(
+        schema_version = 1L,
+        engine = engine,
+        contrasts = setNames(postde_bundles, ids)
+    )
+    path <- file.path(outdir, paste0("DE_", engine, "_", combi, "_postde.rds"))
+    saveRDS(bundle, path)
+    invisible(path)
+}
diff --git a/scripts/Analysis/PostDE/regulatory.R b/scripts/Analysis/PostDE/regulatory.R
new file mode 100644
index 00000000..bc7ca47e
--- /dev/null
+++ b/scripts/Analysis/PostDE/regulatory.R
@@ -0,0 +1,406 @@
+postde_read_network <- function(path, source_col = "source", target_col = "target", mor_col = "mor") {
+    if (is.null(source_col)) source_col <- "source"
+    if (is.null(target_col)) target_col <- "target"
+    if (is.null(mor_col)) mor_col <- "mor"
+    df <- postde_read_tsv(path, header = TRUE)
+    if (!all(c(source_col, target_col, mor_col) %in% colnames(df))) {
+        stop(paste0("network file must have columns ", source_col, ", ", target_col, ", ", mor_col))
+    }
+    df <- df[, c(source_col, target_col, mor_col)]
+    colnames(df) <- c("source", "target", "mor")
+    df
+}
+
+postde_validate_network <- function(net) {
+    net <- as.data.frame(net)
+    if (!all(c("source", "target", "mor") %in% colnames(net))) {
+        stop("network must have source, target and mor columns")
+    }
+    net$source <- as.character(net$source)
+    net$target <- as.character(net$target)
+    net$mor <- as.numeric(net$mor)
+    if (any(is.na(net$source)) || any(!nzchar(net$source)) || any(is.na(net$target)) || any(!nzchar(net$target))) {
+        stop("network contains empty or NA source/target ids")
+    }
+    if (any(!is.finite(net$mor))) {
+        stop("network contains non-finite mor values")
+    }
+    if (any(net$mor == 0)) {
+        stop("network contains zero mor values")
+    }
+    key <- paste(net$source, net$target, sep = "\r")
+    if (anyDuplicated(key)) {
+        stop(paste0("network contains duplicate source-target pairs: ", paste(unique(net$source[duplicated(key)]), collapse = ", ")))
+    }
+    net
+}
+
+postde_check_mlm_rank <- function(net, expr) {
+    net <- as.data.frame(net)
+    expr <- as.matrix(expr)
+    sources <- unique(net$source)
+    if (length(sources) == 0) {
+        stop("no sources in network")
+    }
+    mor_mat <- matrix(0, nrow = nrow(expr), ncol = length(sources), dimnames = list(rownames(expr), sources))
+    for (i in seq_len(nrow(net))) {
+        if (net$target[i] %in% rownames(expr)) {
+            mor_mat[net$target[i], net$source[i]] <- net$mor[i]
+        }
+    }
+    design <- cbind(1, mor_mat)
+    r <- qr(design)$rank
+    if (r < ncol(design)) {
+        stop(paste0("MLM design is rank deficient (rank ", r, " < ", ncol(design), "): sources are collinear with the intercept or each other; remove collinear sources"))
+    }
+    if (nrow(design) - r <= 0) {
+        stop("MLM design has no residual degrees of freedom")
+    }
+    invisible(TRUE)
+}
+
+postde_activity_matrix <- function(acts, sample_names) {
+    acts <- as.data.frame(acts)
+    if (!all(c("source", "condition", "score") %in% colnames(acts))) {
+        stop("decoupler result must contain source, condition and score columns")
+    }
+    if (any(!is.finite(acts$score))) {
+        stop("decoupler activity scores contain non-finite values")
+    }
+    sources <- unique(acts$source)
+    mat <- matrix(NA_real_, nrow = length(sources), ncol = length(sample_names), dimnames = list(sources, sample_names))
+    for (i in seq_len(nrow(acts))) {
+        if (acts$condition[i] %in% sample_names) {
+            mat[acts$source[i], acts$condition[i]] <- acts$score[i]
+        }
+    }
+    if (any(is.na(mat))) {
+        stop("decoupler activity matrix has missing values after pivoting")
+    }
+    mat
+}
+
+postde_run_decoupler <- function(entry, config, outdir) {
+    if (!requireNamespace("decoupleR", quietly = TRUE)) {
+        stop("decoupler enabled but package decoupleR is not installed")
+    }
+    if (!requireNamespace("limma", quietly = TRUE)) {
+        stop("decoupler enabled but package limma is not installed")
+    }
+    dc <- config$decoupler
+    net <- NULL
+    if (!is.null(dc$network)) {
+        net <- postde_read_network(dc$network, dc$source_col, dc$target_col, dc$mor_col)
+    } else {
+        if (!isTRUE(dc$allow_network)) {
+            stop("decoupler network retrieval requires allow_network=true")
+        }
+        resource <- if (is.null(dc$resource)) "collectri" else dc$resource
+        organism <- if (is.null(dc$organism)) "human" else dc$organism
+        if (resource == "collectri") {
+            net <- decoupleR::get_collectri(organism = organism)
+        } else if (resource == "progeny") {
+            top <- if (is.null(dc$top)) 500 else dc$top
+            net <- decoupleR::get_progeny(organism = organism, top = top)
+            if ("weight" %in% colnames(net) && !"mor" %in% colnames(net)) {
+                net$mor <- net$weight
+            }
+        } else {
+            stop(paste0("unknown decoupler resource '", resource, "' (use collectri or progeny)"))
+        }
+        net <- as.data.frame(net)
+        if (!all(c("source", "target", "mor") %in% colnames(net))) {
+            stop(paste0("retrieved resource '", resource, "' lacks source/target/mor columns"))
+        }
+        net <- net[, c("source", "target", "mor")]
+    }
+    net <- postde_validate_network(net)
+    saveRDS(net, file.path(outdir, "decoupler_network.rds"))
+    targets <- intersect(net$target, rownames(entry$expression))
+    if (length(targets) == 0) {
+        stop("no network targets present in expression matrix")
+    }
+    net <- net[net$target %in% targets, , drop = FALSE]
+    net <- decoupleR::rename_net(net, source, target, mor)
+    min_size <- if (is.null(dc$min_size)) config$min_size else dc$min_size
+    net <- decoupleR::filt_minsize(rownames(entry$expression), net, minsize = min_size)
+    if (nrow(net) == 0) {
+        stop("no sources with at least min_size targets after filtering")
+    }
+    write.table(net, file.path(outdir, "decoupler_network_filtered.tsv"), sep = "\t", row.names = FALSE, quote = FALSE)
+    net_meta <- list(
+        coverage = length(intersect(net$target, rownames(entry$expression))) / length(unique(net$target)),
+        checksum = unname(tools::md5sum(file.path(outdir, "decoupler_network_filtered.tsv"))),
+        package = as.character(utils::packageVersion("decoupleR"))
+    )
+    saveRDS(net_meta, file.path(outdir, "decoupler_network_meta.rds"))
+    methods <- unlist(dc$methods)
+    if (is.null(methods)) {
+        methods <- c("ulm", "mlm")
+    }
+    out <- list()
+    for (method in methods) {
+        if (method == "ulm") {
+            acts <- decoupleR::run_ulm(entry$expression, net, minsize = min_size)
+        } else if (method == "mlm") {
+            postde_check_mlm_rank(net, entry$expression)
+            acts <- decoupleR::run_mlm(entry$expression, net, minsize = min_size)
+        } else {
+            stop(paste0("unknown decoupler method '", method, "' (use ulm or mlm)"))
+        }
+        act_mat <- postde_activity_matrix(acts, rownames(entry$design))
+        write.table(act_mat, file.path(outdir, paste0("decoupler_", method, "_activities.tsv")), sep = "\t", col.names = NA, quote = FALSE)
+        diff <- postde_differential_scores(act_mat, entry$design, entry$contrast)
+        write.table(diff$results, file.path(outdir, paste0("decoupler_", method, "_differential.tsv")), sep = "\t", row.names = FALSE, quote = FALSE)
+        write.table(diff$design, file.path(outdir, "decoupler_design.tsv"), sep = "\t", col.names = NA, quote = FALSE)
+        write.table(data.frame(term = names(diff$contrast), coefficient = diff$contrast), file.path(outdir, "decoupler_contrast.tsv"), sep = "\t", row.names = FALSE, quote = FALSE)
+        out[[method]] <- list(status = "ok", activities = file.path(outdir, paste0("decoupler_", method, "_activities.tsv")), differential = file.path(outdir, paste0("decoupler_", method, "_differential.tsv")))
+        if (isTRUE(dc$contrast_activity)) {
+            ca <- data.frame(
+                source = diff$results$feature_id,
+                contrast_activity = diff$results$stat,
+                pvalue = diff$results$pvalue,
+                padj = diff$results$padj,
+                stringsAsFactors = FALSE
+            )
+            write.table(ca, file.path(outdir, paste0("decoupler_", method, "_contrast_activity.tsv")), sep = "\t", row.names = FALSE, quote = FALSE)
+            out[[method]]$contrast_activity <- file.path(outdir, paste0("decoupler_", method, "_contrast_activity.tsv"))
+        }
+    }
+    out
+}
+
+postde_safe_formula <- function(formula) {
+    if (!inherits(formula, "formula")) {
+        stop("dream formula must be a formula")
+    }
+    allowed_ops <- c("~", "+", "-", "*", ":", "/", "|", "||", "(")
+    walk <- function(e) {
+        if (is.name(e) || is.numeric(e)) {
+            return(invisible(TRUE))
+        }
+        if (is.call(e)) {
+            op <- as.character(e[[1]])
+            if (!op %in% allowed_ops) {
+                stop(paste0("dream formula contains disallowed operator/call '", op, "'"))
+            }
+            for (i in 2:length(e)) {
+                walk(e[[i]])
+            }
+            return(invisible(TRUE))
+        }
+        stop(paste0("dream formula contains disallowed element: ", deparse(e)))
+    }
+    walk(formula)
+    invisible(TRUE)
+}
+
+postde_safe_contrast_expr <- function(expr) {
+    if (!is.character(expr) || length(expr) != 1 || !nzchar(expr)) {
+        stop("dream contrast must be a single non-empty string expression")
+    }
+    parsed <- tryCatch(parse(text = expr), error = function(err) {
+        stop(paste0("dream contrast is not parseable: ", conditionMessage(err)))
+    })
+    allowed_ops <- c("+", "-", "*", "/", ":")
+    walk <- function(e) {
+        if (is.name(e) || is.numeric(e)) {
+            return(invisible(TRUE))
+        }
+        if (is.call(e)) {
+            op <- as.character(e[[1]])
+            if (!op %in% allowed_ops) {
+                stop(paste0("dream contrast contains disallowed call '", op, "'"))
+            }
+            for (i in 2:length(e)) {
+                walk(e[[i]])
+            }
+            return(invisible(TRUE))
+        }
+        stop(paste0("dream contrast contains disallowed element: ", deparse(e)))
+    }
+    for (i in seq_along(parsed)) {
+        walk(parsed[[i]])
+    }
+    invisible(TRUE)
+}
+
+postde_fixed_formula <- function(formula) {
+    if (!requireNamespace("lme4", quietly = TRUE)) {
+        stop("lme4 is required for dream but is not installed")
+    }
+    fixed <- suppressWarnings(lme4::nobars(formula))
+    tl <- attr(terms(fixed), "term.labels")
+    if (length(tl) == 0 && attr(terms(fixed), "intercept") == 0) {
+        stop("dream formula has no fixed effects")
+    }
+    fixed
+}
+
+postde_random_group <- function(formula) {
+    if (!requireNamespace("lme4", quietly = TRUE)) {
+        stop("lme4 is required for dream but is not installed")
+    }
+    bars <- suppressWarnings(lme4::findbars(formula))
+    if (length(bars) == 0) {
+        stop("dream formula must include a random effect term like (1|subject)")
+    }
+    groups <- vapply(bars, function(b) {
+        gsub(".*\\|\\s*", "", deparse(b))
+    }, character(1))
+    unique(groups)
+}
+
+postde_run_dream <- function(entry, config, outdir) {
+    if (isTRUE(entry$normalized)) {
+        return(list(status = "skipped: normalized entry; use the ordinary entry"))
+    }
+    if (!requireNamespace("variancePartition", quietly = TRUE)) {
+        stop("dream enabled but package variancePartition is not installed")
+    }
+    if (!requireNamespace("limma", quietly = TRUE)) {
+        stop("dream enabled but package limma is not installed")
+    }
+    if (!requireNamespace("edgeR", quietly = TRUE)) {
+        stop("dream enabled but package edgeR is not installed")
+    }
+    dm <- config$dream
+    if (is.null(dm$metadata)) {
+        stop("dream enabled but metadata path missing")
+    }
+    if (is.null(dm$formula)) {
+        stop("dream enabled but formula missing")
+    }
+    meta <- postde_read_tsv(dm$metadata, header = TRUE)
+    if (!"sample" %in% colnames(meta)) {
+        stop("dream metadata must contain a 'sample' column")
+    }
+    if (anyDuplicated(meta$sample)) {
+        stop("dream metadata contains duplicate sample ids")
+    }
+    if ("condition" %in% colnames(meta)) {
+        stop("dream metadata must not contain a 'condition' column (condition comes from the DE analysis)")
+    }
+    if (!all(rownames(entry$metadata) %in% meta$sample)) {
+        stop("dream metadata is missing samples present in the entry")
+    }
+    entry_meta <- as.data.frame(entry$metadata)
+    entry_meta$sample <- rownames(entry_meta)
+    common_cols <- setdiff(intersect(colnames(meta), colnames(entry_meta)), "sample")
+    for (cc in common_cols) {
+        mm <- merge(entry_meta[, c("sample", cc)], meta[, c("sample", cc)], by = "sample", suffixes = c(".entry", ".dream"))
+        inconsistent <- !is.na(mm[[paste0(cc, ".entry")]]) & !is.na(mm[[paste0(cc, ".dream")]]) & as.character(mm[[paste0(cc, ".entry")]]) != as.character(mm[[paste0(cc, ".dream")]])
+        if (any(inconsistent)) {
+            stop(paste0("dream metadata column '", cc, "' has values inconsistent with the entry metadata"))
+        }
+    }
+    if (length(common_cols) > 0) {
+        meta <- meta[, setdiff(colnames(meta), common_cols), drop = FALSE]
+    }
+    data <- merge(entry_meta, meta, by = "sample", all.x = TRUE)
+    rownames(data) <- data$sample
+    data <- data[colnames(entry$counts), , drop = FALSE]
+    formula <- as.formula(dm$formula)
+    postde_safe_formula(formula)
+    groups <- postde_random_group(formula)
+    for (group in groups) {
+        if (!group %in% colnames(data)) {
+            stop(paste0("dream random grouping variable '", group, "' not found in metadata"))
+        }
+        tab <- table(data[[group]])
+        if (sum(tab >= 2) < 2) {
+            stop(paste0("dream random grouping variable '", group, "' must have at least 2 groups with more than 1 sample each"))
+        }
+    }
+    fixed <- postde_fixed_formula(formula)
+    fixed_design <- model.matrix(fixed, data = data)
+    r <- qr(fixed_design)$rank
+    if (r < ncol(fixed_design)) {
+        stop("dream fixed design is not full rank")
+    }
+    if (nrow(fixed_design) - r <= 0) {
+        stop("dream fixed design has no residual degrees of freedom")
+    }
+    dge <- edgeR::DGEList(counts = entry$counts)
+    keep <- edgeR::filterByExpr(dge, design = fixed_design)
+    dge <- dge[keep, , keep.lib.sizes = FALSE]
+    dge <- edgeR::calcNormFactors(dge, method = "TMM")
+    vobj <- variancePartition::voomWithDreamWeights(dge, formula, data)
+    if (!is.null(dm$contrasts)) {
+        contrasts <- unlist(dm$contrasts)
+        for (nm in names(contrasts)) {
+            postde_safe_contrast_expr(contrasts[[nm]])
+        }
+        L <- variancePartition::makeContrastsDream(formula, data, contrasts = contrasts)
+    } else {
+        if (!"condition" %in% colnames(data)) {
+            stop("dream default contrast A-B requires 'condition' in the formula/metadata")
+        }
+        cvec <- postde_contrast(fixed, data, entry$A, entry$B)
+        if (!identical(names(cvec), colnames(fixed_design))) {
+            stop("dream default contrast names do not match fixed design columns")
+        }
+        L <- matrix(cvec, ncol = 1, dimnames = list(names(cvec), "A-B"))
+    }
+    fit <- variancePartition::dream(vobj, formula, data, L = L)
+    fit <- variancePartition::eBayes(fit)
+    out <- list()
+    if (!is.null(dm$contrasts)) {
+        for (nm in colnames(L)) {
+            tt <- limma::topTable(fit, number = Inf, sort.by = "none", coef = nm)
+            res <- data.frame(
+                gene_id = rownames(tt),
+                logFC = tt$logFC,
+                pvalue = tt$P.Value,
+                padj = tt$adj.P.Val,
+                stat = tt$t,
+                mean = tt$AveExpr,
+                stringsAsFactors = FALSE
+            )
+            res_file <- file.path(outdir, paste0("dream_result_", postde_sanitize_id(nm), ".tsv"))
+            write.table(res, res_file, sep = "\t", row.names = FALSE, quote = FALSE)
+            out[[nm]] <- list(status = "ok", result = res_file)
+        }
+    } else {
+        tt <- limma::topTable(fit, number = Inf, sort.by = "none", coef = "A-B")
+        res <- data.frame(
+            gene_id = rownames(tt),
+            logFC = tt$logFC,
+            pvalue = tt$P.Value,
+            padj = tt$adj.P.Val,
+            stat = tt$t,
+            mean = tt$AveExpr,
+            stringsAsFactors = FALSE
+        )
+        res_file <- file.path(outdir, "dream_result.tsv")
+        write.table(res, res_file, sep = "\t", row.names = FALSE, quote = FALSE)
+        out[["A-B"]] <- list(status = "ok", result = res_file)
+    }
+    write.table(fixed_design, file.path(outdir, "dream_design.tsv"), sep = "\t", col.names = NA, quote = FALSE)
+    writeLines(dm$formula, file.path(outdir, "dream_formula.txt"))
+    writeLines(rownames(dge), file.path(outdir, "dream_filtered_genes.txt"))
+    saveRDS(L, file.path(outdir, "dream_contrast.rds"))
+    varpart <- tryCatch(
+        variancePartition::fitExtractVarPartModel(vobj, formula, data),
+        error = function(e) structure(conditionMessage(e), class = "postde_varpart_error")
+    )
+    if (inherits(varpart, "postde_varpart_error")) {
+        writeLines(as.character(varpart), file.path(outdir, "dream_varpart_status.txt"))
+        out$varpart <- list(status = "error", message = as.character(varpart))
+    } else {
+        saveRDS(varpart, file.path(outdir, "dream_varpart.rds"))
+        out$varpart <- list(status = "ok", result = file.path(outdir, "dream_varpart.rds"))
+    }
+    out
+}
+
+postde_run_regulatory <- function(entry, config, outdir) {
+    out <- list()
+    if (is.list(config$decoupler) && isTRUE(config$decoupler$enabled)) {
+        out$decoupler <- postde_run_decoupler(entry, config, outdir)
+    }
+    if (is.list(config$dream) && isTRUE(config$dream$enabled)) {
+        out$dream <- postde_run_dream(entry, config, outdir)
+    }
+    out
+}
diff --git a/scripts/Analysis/PostDE/run.R b/scripts/Analysis/PostDE/run.R
new file mode 100644
index 00000000..04d7e3b2
--- /dev/null
+++ b/scripts/Analysis/PostDE/run.R
@@ -0,0 +1,199 @@
+postde_parse_cli <- function(args) {
+    out <- list(bundle = NULL, config = NULL, output = NULL)
+    i <- 1
+    while (i <= length(args)) {
+        a <- args[i]
+        if (grepl("^--bundle=", a)) {
+            out$bundle <- sub("^--bundle=", "", a)
+        } else if (a == "--bundle") {
+            if (i >= length(args)) stop("--bundle requires a value")
+            out$bundle <- args[i + 1]
+            i <- i + 1
+        } else if (grepl("^--config=", a)) {
+            out$config <- sub("^--config=", "", a)
+        } else if (a == "--config") {
+            if (i >= length(args)) stop("--config requires a value")
+            out$config <- args[i + 1]
+            i <- i + 1
+        } else if (grepl("^--output=", a)) {
+            out$output <- sub("^--output=", "", a)
+        } else if (a == "--output") {
+            if (i >= length(args)) stop("--output requires a value")
+            out$output <- args[i + 1]
+            i <- i + 1
+        } else {
+            stop(paste0("unknown argument: ", a))
+        }
+        i <- i + 1
+    }
+    if (is.null(out$bundle) || is.null(out$config) || is.null(out$output)) {
+        stop("usage: Rscript run.R --bundle FILE --config JSON --output DIR")
+    }
+    out
+}
+
+postde_config_defaults <- function(config) {
+    if (is.null(config$padj)) config$padj <- 0.05
+    if (is.null(config$lfc)) config$lfc <- 1
+    if (is.null(config$seed)) config$seed <- 1
+    if (is.null(config$min_size)) config$min_size <- 10
+    if (is.null(config$max_size)) config$max_size <- 500
+    config
+}
+
+postde_config_enabled <- function(sub) {
+    is.list(sub) && isTRUE(sub$enabled)
+}
+
+postde_validate_config <- function(config) {
+    if (!is.null(config$padj) && (!is.numeric(config$padj) || config$padj <= 0 || config$padj >= 1)) {
+        stop("config padj must be numeric in (0, 1)")
+    }
+    if (!is.null(config$lfc) && (!is.numeric(config$lfc) || config$lfc < 0)) {
+        stop("config lfc must be numeric >= 0")
+    }
+    if (!is.null(config$seed) && !is.numeric(config$seed)) {
+        stop("config seed must be numeric")
+    }
+    if (!is.null(config$min_size) && (!is.numeric(config$min_size) || config$min_size < 1)) {
+        stop("config min_size must be numeric >= 1")
+    }
+    if (!is.null(config$max_size) && (!is.numeric(config$max_size) || config$max_size < config$min_size)) {
+        stop("config max_size must be numeric >= min_size")
+    }
+    for (sub in c("gprofiler", "clusterprofiler", "gsva", "decoupler", "dream", "plots", "report", "shiny")) {
+        if (!is.null(config[[sub]]) && !is.list(config[[sub]])) {
+            stop(paste0("config ", sub, " must be an object"))
+        }
+        if (is.list(config[[sub]]) && !is.null(config[[sub]]$enabled) && !is.logical(config[[sub]]$enabled)) {
+            stop(paste0("config ", sub, ".enabled must be a boolean"))
+        }
+    }
+    invisible(TRUE)
+}
+
+postde_validate_bundle <- function(bundle) {
+    if (!is.list(bundle) || is.null(bundle$schema_version) || is.null(bundle$engine) || is.null(bundle$contrasts)) {
+        stop("bundle is not a valid postde bundle (schema_version, engine, contrasts required)")
+    }
+    if (!identical(bundle$schema_version, 1L) && !identical(bundle$schema_version, 1)) {
+        stop(paste0("unsupported bundle schema_version: ", bundle$schema_version))
+    }
+    if (length(bundle$contrasts) == 0) {
+        stop("bundle contains no contrast entries")
+    }
+    ids <- vapply(bundle$contrasts, function(e) e$id, character(1))
+    if (anyDuplicated(ids)) {
+        stop(paste0("bundle contains duplicate entry ids: ", paste(ids[duplicated(ids)], collapse = ", ")))
+    }
+    postde_check_sanitized_ids(ids)
+    for (id in ids) {
+        if (grepl("[/\\\\]", id) || id == "." || id == "..") {
+            stop(paste0("bundle entry id is unsafe: '", id, "'"))
+        }
+    }
+    invisible(TRUE)
+}
+
+postde_script_dir <- function() {
+    args <- commandArgs(trailingOnly = FALSE)
+    file_arg <- sub("^--file=", "", args[grep("^--file=", args)])
+    if (length(file_arg) == 0) {
+        stop("Rscript --file path not found in commandArgs")
+    }
+    dirname(normalizePath(file_arg))
+}
+
+postde_relpath <- function(path, base) {
+    path <- normalizePath(path, mustWork = FALSE)
+    base <- normalizePath(base, mustWork = FALSE)
+    if (identical(path, base)) {
+        return(".")
+    }
+    if (startsWith(path, paste0(base, .Platform$file.sep))) {
+        return(substr(path, nchar(base) + 2, nchar(path)))
+    }
+    path
+}
+
+postde_relativize <- function(x, base) {
+    if (is.character(x) && length(x) == 1 && !is.na(x) && startsWith(x, base)) {
+        return(postde_relpath(x, base))
+    }
+    if (is.list(x)) {
+        return(lapply(x, postde_relativize, base = base))
+    }
+    x
+}
+
+postde_main <- function() {
+    cli <- postde_parse_cli(commandArgs(trailingOnly = TRUE))
+    if (!file.exists(cli$bundle)) {
+        stop(paste0("bundle file not found: ", cli$bundle))
+    }
+    if (!file.exists(cli$config)) {
+        stop(paste0("config file not found: ", cli$config))
+    }
+    if (!requireNamespace("jsonlite", quietly = TRUE)) {
+        stop("jsonlite is required but is not installed")
+    }
+    script_dir <- postde_script_dir()
+    source(file.path(script_dir, "common.R"))
+    source(file.path(script_dir, "enrichment.R"))
+    source(file.path(script_dir, "regulatory.R"))
+    bundle <- readRDS(cli$bundle)
+    config <- postde_config_defaults(jsonlite::fromJSON(cli$config, simplifyVector = FALSE))
+    postde_validate_bundle(bundle)
+    postde_validate_config(config)
+    if (!dir.exists(cli$output)) {
+        dir.create(cli$output, recursive = TRUE)
+    }
+    set.seed(config$seed)
+    outputs <- list()
+    for (entry_name in names(bundle$contrasts)) {
+        entry <- bundle$contrasts[[entry_name]]
+        if (!is.list(entry) || is.null(entry$id)) {
+            stop(paste0("bundle contrast '", entry_name, "' is not a valid entry (id required)"))
+        }
+        entry_dir <- file.path(cli$output, postde_sanitize_id(entry$id))
+        dir.create(entry_dir, recursive = TRUE, showWarnings = FALSE)
+        entry_outputs <- list()
+        if (postde_config_enabled(config$gprofiler)) {
+            entry_outputs$gprofiler <- postde_run_gprofiler(entry, config, entry_dir)
+        }
+        if (postde_config_enabled(config$clusterprofiler) || postde_config_enabled(config$gsva)) {
+            entry_outputs$enrichment <- postde_run_enrichment(entry, config, entry_dir)
+        }
+        if (postde_config_enabled(config$decoupler) || postde_config_enabled(config$dream)) {
+            entry_outputs$regulatory <- postde_run_regulatory(entry, config, entry_dir)
+        }
+        outputs[[entry$id]] <- list(id = entry$id, dir = entry_dir, analyses = entry_outputs)
+    }
+    report_data <- list(config = config, bundle = bundle, outputs = outputs)
+    saveRDS(report_data, file.path(cli$output, "report_data.rds"))
+    manifest <- list(
+        bundle = postde_relpath(cli$bundle, cli$output),
+        config = postde_relpath(cli$config, cli$output),
+        output = ".",
+        bundle_checksum = unname(tools::md5sum(cli$bundle)),
+        config_checksum = unname(tools::md5sum(cli$config)),
+        entries = lapply(outputs, function(o) list(id = o$id, dir = postde_relpath(o$dir, cli$output), analyses = postde_relativize(o$analyses, cli$output))),
+        sessionInfo = capture.output(utils::sessionInfo())
+    )
+    jsonlite::write_json(manifest, file.path(cli$output, "manifest.json"), pretty = TRUE, auto_unbox = TRUE)
+    any_vis <- postde_config_enabled(config$plots) || postde_config_enabled(config$report) || postde_config_enabled(config$shiny)
+    if (any_vis) {
+        reporting <- file.path(script_dir, "reporting.R")
+        if (file.exists(reporting)) {
+            source(reporting)
+        }
+        if (exists("render_postde", mode = "function")) {
+            render_postde(bundle, config, cli$output)
+        } else {
+            stop("plots/report/shiny enabled but render_postde() is not available (reporting.R not yet provided)")
+        }
+    }
+    invisible(report_data)
+}
+
+postde_main()
diff --git a/tests/postde_core.R b/tests/postde_core.R
new file mode 100644
index 00000000..28b8a5c9
--- /dev/null
+++ b/tests/postde_core.R
@@ -0,0 +1,323 @@
+#!/usr/bin/env Rscript
+args <- commandArgs(trailingOnly = TRUE)
+outdir <- if (length(args) >= 1) args[1] else tempfile("postde_fixture_")
+dir.create(outdir, recursive = TRUE, showWarnings = FALSE)
+
+script_dir <- dirname(normalizePath(sub("^--file=", "", commandArgs(trailingOnly = FALSE)[grep("^--file=", commandArgs(trailingOnly = FALSE))])))
+postde_dir <- file.path(script_dir, "..", "scripts", "Analysis", "PostDE")
+source(file.path(postde_dir, "common.R"))
+source(file.path(postde_dir, "export.R"))
+source(file.path(postde_dir, "enrichment.R"))
+source(file.path(postde_dir, "regulatory.R"))
+
+suppressPackageStartupMessages({
+    library(DESeq2)
+    library(edgeR)
+    library(limma)
+    library(GSVA)
+    library(BiocParallel)
+    library(decoupleR)
+    library(variancePartition)
+    library(clusterProfiler)
+    library(GO.db)
+    library(jsonlite)
+})
+
+set.seed(42)
+summary <- list()
+
+## synthetic cohort: 300 genes, 8 samples, 2 conditions
+ngenes <- 300
+samples <- paste0("s", 1:8)
+cond <- factor(rep(c("B", "A"), each = 4), levels = c("B", "A"))
+metadata <- data.frame(condition = cond, row.names = samples)
+base <- exp(rnorm(ngenes, mean = 6, sd = 1.5))
+effect <- rnorm(ngenes, mean = 0, sd = 1)
+counts <- matrix(rnbinom(ngenes * 8, mu = base, size = 5), nrow = ngenes, dimnames = list(paste0("g", 1:ngenes), samples))
+counts[, cond == "A"] <- matrix(rnbinom(ngenes * 4, mu = base * exp(effect), size = 5), nrow = ngenes)
+counts <- round(counts)
+counts[counts < 0] <- 0
+
+## real DESeq2 fit
+dds <- DESeqDataSetFromMatrix(countData = counts, colData = metadata, design = ~condition)
+dds$condition <- relevel(dds$condition, ref = "B")
+dds <- DESeq(dds, betaPrior = FALSE)
+res <- results(dds, contrast = c("condition", "A", "B"))
+vsd <- varianceStabilizingTransformation(dds, blind = FALSE)
+res_df <- postde_results_deseq2(res)
+summary$deseq2_rownames_aligned <- identical(rownames(res_df), rownames(res))
+summary$deseq2_gene_id_matches <- all(rownames(res_df) == res_df$gene_id)
+
+## real edgeR fit
+dge <- DGEList(counts = counts, group = cond)
+keep <- filterByExpr(dge)
+dge <- dge[keep, , keep.lib.sizes = FALSE]
+dge <- calcNormFactors(dge)
+design <- model.matrix(~condition, data = metadata)
+dge <- estimateDisp(dge, design)
+fit <- glmQLFit(dge, design)
+qlf <- glmQLFTest(fit, contrast = c(0, 1))
+qlf_df <- postde_results_edger(qlf)
+summary$edger_rownames_aligned <- identical(rownames(qlf_df), rownames(qlf$table))
+summary$edger_gene_id_matches <- all(rownames(qlf_df) == qlf_df$gene_id)
+summary$edger_stat_finite <- all(is.finite(qlf_df$stat[is.finite(qlf$table$F)]))
+summary$edger_stat_na_noF <- all(is.na(qlf_df$stat[!is.finite(qlf$table$F)]))
+
+## capture bundles (deseq2 and edger separately)
+postde_bundles <- list()
+postde_capture(engine = "deseq2", id = "A_vs_B", A = "A", B = "B", normalized = FALSE, metadata = metadata, counts = counts, expression = assay(vsd), formula = ~condition, results = res_df, mean_scale = "baseMean")
+postde_write(outdir, "test", "deseq2")
+deseq2_bundle <- readRDS(file.path(outdir, "DE_deseq2_test_postde.rds"))
+deseq2_entry <- deseq2_bundle$contrasts[["A_vs_B"]]
+
+postde_bundles <- list()
+postde_capture(engine = "edger", id = "A_vs_B", A = "A", B = "B", normalized = FALSE, metadata = metadata, counts = counts, expression = cpm(dge, log = TRUE), formula = ~condition, results = qlf_df, mean_scale = "logCPM")
+postde_write(outdir, "test", "edger")
+edger_bundle <- readRDS(file.path(outdir, "DE_edger_test_postde.rds"))
+edger_entry <- edger_bundle$contrasts[["A_vs_B"]]
+
+## capture must reject misaligned rownames (known defect guard)
+bad_res <- res_df
+rownames(bad_res) <- rev(rownames(bad_res))
+summary$capture_rejects_misaligned <- inherits(tryCatch(
+    postde_capture(engine = "deseq2", id = "bad", A = "A", B = "B", normalized = FALSE, metadata = metadata, counts = counts, expression = assay(vsd), formula = ~condition, results = bad_res, mean_scale = "baseMean"),
+    error = function(e) e
+), "error")
+
+## counts superset allowed: counts with extra genes
+extra_counts <- rbind(counts, matrix(1, nrow = 5, ncol = 8, dimnames = list(paste0("extra", 1:5), samples)))
+postde_bundles <- list()
+postde_capture(engine = "deseq2", id = "superset", A = "A", B = "B", normalized = FALSE, metadata = metadata, counts = extra_counts, expression = assay(vsd), formula = ~condition, results = res_df, mean_scale = "baseMean")
+summary$capture_counts_superset_ok <- length(postde_bundles) == 1
+
+## GSVA scores vs direct call
+gene_sets <- list(
+    set1 = paste0("g", 1:20),
+    set2 = paste0("g", 50:80),
+    set3 = paste0("g", 100:130),
+    set4 = paste0("g", 200:230)
+)
+expr <- assay(vsd)
+scores <- postde_gsva_scores(expr, gene_sets, method = "gsva", min_size = 5, max_size = 100)
+param <- GSVA::gsvaParam(exprData = expr, geneSets = gene_sets, minSize = 5, maxSize = 100, kcdf = "Gaussian")
+scores_direct <- GSVA::gsva(param, BPPARAM = BiocParallel::SerialParam())
+summary$gsva_max_diff <- max(abs(scores - scores_direct))
+
+## differential scores vs direct limma
+contrast <- deseq2_entry$contrast
+diff <- postde_differential_scores(scores, deseq2_entry$design, contrast)
+fit <- lmFit(scores, deseq2_entry$design)
+fit2 <- contrasts.fit(fit, contrast)
+fit2 <- eBayes(fit2)
+tt <- topTable(fit2, number = nrow(scores), sort.by = "none")
+summary$diff_score_difference_max_diff <- max(abs(diff$results$score_difference - tt$logFC))
+summary$diff_stat_max_diff <- max(abs(diff$results$stat - tt$t))
+summary$diff_columns <- paste(colnames(diff$results), collapse = ",")
+summary$diff_feature_names_preserved <- identical(diff$results$feature_id, rownames(scores))
+
+## decoupler ULM/MLM vs direct calls
+net <- data.frame(
+    source = c("TF1", "TF1", "TF1", "TF2", "TF2", "TF2", "TF3", "TF3", "TF3"),
+    target = c("g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8", "g9"),
+    mor = c(1, 1, -1, 1, -1, 1, -1, 1, 1)
+)
+net_path <- file.path(outdir, "test_network.tsv")
+write.table(net, net_path, sep = "\t", row.names = FALSE, quote = FALSE)
+dc_config <- list(enabled = TRUE, network = net_path, min_size = 1, methods = list("ulm", "mlm"))
+dc_out <- postde_run_decoupler(deseq2_entry, list(min_size = 1, decoupler = dc_config), outdir)
+acts_ulm <- decoupleR::run_ulm(expr, net, minsize = 1)
+acts_mlm <- decoupleR::run_mlm(expr, net, minsize = 1)
+ulm_mat <- postde_activity_matrix(acts_ulm, rownames(deseq2_entry$design))
+mlm_mat <- postde_activity_matrix(acts_mlm, rownames(deseq2_entry$design))
+summary$ulm_max_diff <- max(abs(read.delim(dc_out$ulm$activities, row.names = 1, check.names = FALSE) - ulm_mat))
+summary$mlm_max_diff <- max(abs(read.delim(dc_out$mlm$activities, row.names = 1, check.names = FALSE) - mlm_mat))
+summary$decoupler_network_meta_exists <- file.exists(file.path(outdir, "decoupler_network_meta.rds"))
+summary$decoupler_filtered_tsv_exists <- file.exists(file.path(outdir, "decoupler_network_filtered.tsv"))
+
+## decoupler gating: no allow_network -> error
+dc_net_config <- list(enabled = TRUE, resource = "collectri", organism = "human", min_size = 1, methods = list("ulm"))
+summary$decoupler_gated_without_network <- inherits(tryCatch(
+    postde_run_decoupler(deseq2_entry, list(min_size = 1, decoupler = dc_net_config), outdir),
+    error = function(e) e
+), "error")
+
+## decoupler MLM rank deficiency -> error (collinear sources)
+collinear_net <- data.frame(
+    source = c("TF1", "TF1", "TF2", "TF2"),
+    target = c("g1", "g2", "g1", "g2"),
+    mor = c(1, 1, 2, 2)
+)
+collinear_path <- file.path(outdir, "collinear_network.tsv")
+write.table(collinear_net, collinear_path, sep = "\t", row.names = FALSE, quote = FALSE)
+dc_collinear <- list(enabled = TRUE, network = collinear_path, min_size = 1, methods = list("mlm"))
+summary$mlm_rank_deficiency_rejected <- inherits(tryCatch(
+    postde_run_decoupler(deseq2_entry, list(min_size = 1, decoupler = dc_collinear), outdir),
+    error = function(e) e
+), "error")
+
+## GO expansion vs clusterProfiler::buildGOmap
+t2g <- data.frame(
+    term = c("GO:0006915", "GO:0006915", "GO:0005737", "GO:0003677"),
+    gene = c("g1", "g2", "g3", "g4")
+)
+gomap <- postde_build_gomap(t2g)
+gomap_direct <- clusterProfiler::buildGOmap(t2g)
+summary$gomap_identical <- identical(gomap, gomap_direct)
+summary$gomap_expanded_rows <- nrow(gomap)
+summary$gomap_unknown_term_rejected <- inherits(tryCatch(
+    postde_build_gomap(data.frame(term = "GO:FAKE0001", gene = "g1")),
+    error = function(e) e
+), "error")
+
+## term2gene/term2name strict validation
+t2g_ora <- data.frame(
+    term = c(
+        rep("GO:0006915", 25), rep("GO:0005737", 25),
+        rep("GO:0003677", 25), rep("GO:0005575", 25)
+    ),
+    gene = c(paste0("g", 1:25), paste0("g", 26:50), paste0("g", 51:75), paste0("g", 76:100))
+)
+t2g_path <- file.path(outdir, "term2gene.tsv")
+write.table(t2g_ora, t2g_path, sep = "\t", row.names = FALSE, quote = FALSE)
+t2n_path <- file.path(outdir, "term2name.tsv")
+write.table(data.frame(term = c("GO:0006915", "GO:0005737", "GO:0003677", "GO:0005575"), name = c("apoptotic process", "cytoplasm", "DNA binding", "cellular_component")), t2n_path, sep = "\t", row.names = FALSE, quote = FALSE)
+summary$term2gene_strict <- inherits(tryCatch(postde_read_term2gene(t2g_path), error = function(e) e), "data.frame")
+summary$term2name_strict <- inherits(tryCatch(postde_read_term2name(t2n_path), error = function(e) e), "data.frame")
+summary$term2gene_extra_col_rejected <- inherits(tryCatch(
+    postde_read_term2gene(file.path(outdir, "term2gene_extra.tsv")),
+    error = function(e) e
+), "error")
+write.table(cbind(t2g, extra = 1), file.path(outdir, "term2gene_extra.tsv"), sep = "\t", row.names = FALSE, quote = FALSE)
+
+## ORA all/up/down separate files via postde_run_enrichment
+cp_config <- list(
+    enabled = TRUE,
+    term2gene = t2g_path,
+    term2name = t2n_path,
+    go_expand = FALSE
+)
+enr_out <- postde_run_enrichment(deseq2_entry, list(padj = 0.99, lfc = 0, min_size = 1, max_size = 500, seed = 1, clusterprofiler = cp_config), outdir)
+summary$ora_separate_files <- all(file.exists(file.path(outdir, c("enricher_all_result.tsv", "enricher_up_result.tsv", "enricher_down_result.tsv"))))
+summary$enrichment_provenance_exists <- file.exists(file.path(outdir, "enrichment_provenance.rds"))
+
+## GSEA rank unavailable vs no hits
+no_stat <- deseq2_entry$results
+no_stat$stat <- NULL
+gsea_no_stat <- postde_run_gsea(list(results = no_stat), t2g, NULL, 1, 500, 1, outdir)
+summary$gsea_rank_unavailable_status <- gsea_no_stat$status
+gsea_ok <- postde_run_gsea(deseq2_entry, t2g, NULL, 1, 500, 1, outdir)
+summary$gsea_ranked_saved <- file.exists(file.path(outdir, "gsea_ranked.rds"))
+summary$gsea_status <- gsea_ok$status
+
+## dream: repeated subjects fixture (8 subjects, 16 samples, 300 genes)
+subjects <- paste0("subj", 1:8)
+dream_samples <- paste0("d", 1:16)
+dream_cond <- factor(rep(rep(c("B", "A"), each = 1), 8), levels = c("B", "A"))
+dream_subject <- factor(rep(subjects, each = 2))
+dream_meta <- data.frame(condition = dream_cond, subject = dream_subject, row.names = dream_samples)
+dream_base <- exp(rnorm(ngenes, mean = 6, sd = 1.5))
+dream_effect <- rnorm(ngenes, mean = 0, sd = 1)
+dream_counts <- matrix(rnbinom(ngenes * 16, mu = dream_base, size = 5), nrow = ngenes, dimnames = list(paste0("g", 1:ngenes), dream_samples))
+dream_counts[, dream_cond == "A"] <- matrix(rnbinom(ngenes * 8, mu = dream_base * exp(dream_effect), size = 5), nrow = ngenes)
+dream_counts <- round(dream_counts)
+dream_meta_path <- file.path(outdir, "dream_metadata.tsv")
+write.table(data.frame(sample = dream_samples, subject = dream_subject), dream_meta_path, sep = "\t", row.names = FALSE, quote = FALSE)
+dream_entry <- list(
+    id = "dream_test",
+    A = "A",
+    B = "B",
+    normalized = FALSE,
+    metadata = dream_meta,
+    counts = dream_counts,
+    expression = log2(dream_counts + 1),
+    design = model.matrix(~condition, data = dream_meta),
+    contrast = postde_contrast(~condition, dream_meta, "A", "B"),
+    results = NULL,
+    mean_scale = "baseMean"
+)
+dm_config <- list(enabled = TRUE, metadata = dream_meta_path, formula = "~ condition + (1|subject)")
+dream_out <- postde_run_dream(dream_entry, list(dream = dm_config), outdir)
+dream_res <- read.delim(file.path(outdir, "dream_result.tsv"), check.names = FALSE)
+fixed_design <- model.matrix(~condition, data = dream_meta)
+dge_d <- DGEList(counts = dream_counts)
+keep_d <- filterByExpr(dge_d, design = fixed_design)
+dge_d <- dge_d[keep_d, , keep.lib.sizes = FALSE]
+dge_d <- calcNormFactors(dge_d, method = "TMM")
+vobj_d <- voom(dge_d, fixed_design)
+fit_d <- lmFit(vobj_d, fixed_design)
+fit_d <- eBayes(fit_d)
+tt_d <- topTable(fit_d, number = Inf, sort.by = "none")
+common_genes <- intersect(dream_res$gene_id, rownames(tt_d))
+summary$dream_max_logfc_diff <- max(abs(dream_res$logFC[match(common_genes, dream_res$gene_id)] - tt_d$logFC[match(common_genes, rownames(tt_d))]))
+summary$dream_varpart_status <- dream_out$varpart$status
+summary$dream_varpart_status_file <- file.exists(file.path(outdir, "dream_varpart_status.txt"))
+vp_ok <- tryCatch(
+    variancePartition::fitExtractVarPartModel(vobj_d, ~ (1 | condition) + (1 | subject), dream_meta),
+    error = function(e) e
+)
+summary$dream_varpart_ok_path <- !inherits(vp_ok, "error")
+summary$dream_skipped_normalized <- postde_run_dream(list(normalized = TRUE), list(dream = dm_config), outdir)$status
+
+## dream safe formula/contrast validation
+summary$dream_safe_formula_ok <- inherits(tryCatch(postde_safe_formula(~condition + (1|subject)), error = function(e) e), "logical")
+summary$dream_unsafe_formula_rejected <- inherits(tryCatch(
+    postde_safe_formula(~condition + system("echo hi")),
+    error = function(e) e
+), "error")
+summary$dream_safe_contrast_ok <- inherits(tryCatch(postde_safe_contrast_expr("conditionA - conditionB"), error = function(e) e), "logical")
+summary$dream_unsafe_contrast_rejected <- inherits(tryCatch(
+    postde_safe_contrast_expr("conditionA; system('echo hi')"),
+    error = function(e) e
+), "error")
+
+## empty TSV header-first with status sidecar
+empty_path <- file.path(outdir, "empty_result.tsv")
+postde_write_empty(empty_path, "no significant genes")
+empty_lines <- readLines(empty_path)
+summary$empty_tsv_header_first <- identical(empty_lines[1], "gene_id\tlogFC\tpvalue\tpadj\tstat\tmean")
+summary$empty_tsv_status_sidecar <- file.exists(paste0(empty_path, ".status.json"))
+
+## significant thresholds strict padj< and |lfc|>=
+sig_res <- data.frame(
+    gene_id = c("a", "b", "c", "d"),
+    logFC = c(1, 1, 2, 2),
+    pvalue = c(0.01, 0.01, 0.01, 0.01),
+    padj = c(0.05, 0.049, 0.05, 0.049),
+    stringsAsFactors = FALSE
+)
+sig_all <- postde_significant(sig_res, direction = "all", padj = 0.05, lfc = 1)
+summary$sig_threshold_strict <- identical(sig_all, c("b", "d"))
+sig_na <- sig_res
+sig_na$logFC[1] <- NA
+summary$sig_never_select_na_effect <- !any(is.na(postde_significant(sig_na, direction = "all", padj = 0.05, lfc = 1)))
+
+## differential scores singleton handling: 0 residual df -> clean error
+singleton_meta <- data.frame(condition = factor(c("B", "A")), row.names = c("x1", "x2"))
+singleton_design <- model.matrix(~condition, data = singleton_meta)
+singleton_contrast <- postde_contrast(~condition, singleton_meta, "A", "B")
+singleton_scores <- matrix(rnorm(4), nrow = 2, dimnames = list(c("f1", "f2"), c("x1", "x2")))
+summary$singleton_no_residual_df_rejected <- inherits(tryCatch(
+    postde_differential_scores(singleton_scores, singleton_design, singleton_contrast),
+    error = function(e) e
+), "error")
+
+## design validation: named contrast aligned by name, zero intercept rejected
+named_contrast <- setNames(c(0, -1), c("(Intercept)", "conditionA"))
+summary$design_named_contrast_aligned <- inherits(tryCatch(
+    postde_validate_design(design, named_contrast),
+    error = function(e) e
+), "logical")
+summary$design_zero_intercept_rejected <- inherits(tryCatch(
+    postde_validate_design(design, c(1, 0)),
+    error = function(e) e
+), "error")
+
+## safe ids
+summary$sanitize_dot_rejected <- inherits(tryCatch(postde_sanitize_id(".."), error = function(e) e), "error")
+summary$sanitize_collision_detected <- inherits(tryCatch(
+    postde_check_sanitized_ids(c("a/b", "a_b")),
+    error = function(e) e
+), "error")
+
+writeLines(toJSON(summary, auto_unbox = TRUE, pretty = TRUE), file.path(outdir, "summary.json"))
+cat("POSTDE_FIXTURE_OK", outdir, "\n")
diff --git a/tests/test_postde_core.py b/tests/test_postde_core.py
new file mode 100644
index 00000000..173ed0b5
--- /dev/null
+++ b/tests/test_postde_core.py
@@ -0,0 +1,299 @@
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+RSCRIPT = shutil.which("Rscript")
+pytestmark = pytest.mark.skipif(
+    RSCRIPT is None, reason="Rscript is not on PATH; activate the postde Conda environment"
+)
+POSTDE_DIR = ROOT / "scripts" / "Analysis" / "PostDE"
+FIXTURE = ROOT / "tests" / "postde_core.R"
+
+REQUIRED_SUMMARY_CHECKS = [
+    "deseq2_rownames_aligned",
+    "deseq2_gene_id_matches",
+    "edger_rownames_aligned",
+    "edger_gene_id_matches",
+    "edger_stat_finite",
+    "edger_stat_na_noF",
+    "capture_rejects_misaligned",
+    "capture_counts_superset_ok",
+    "diff_feature_names_preserved",
+    "decoupler_network_meta_exists",
+    "decoupler_filtered_tsv_exists",
+    "decoupler_gated_without_network",
+    "mlm_rank_deficiency_rejected",
+    "gomap_identical",
+    "gomap_unknown_term_rejected",
+    "term2gene_strict",
+    "term2name_strict",
+    "term2gene_extra_col_rejected",
+    "ora_separate_files",
+    "enrichment_provenance_exists",
+    "gsea_ranked_saved",
+    "dream_varpart_status_file",
+    "dream_varpart_ok_path",
+    "dream_safe_formula_ok",
+    "dream_unsafe_formula_rejected",
+    "dream_safe_contrast_ok",
+    "dream_unsafe_contrast_rejected",
+    "empty_tsv_header_first",
+    "empty_tsv_status_sidecar",
+    "sig_threshold_strict",
+    "sig_never_select_na_effect",
+    "singleton_no_residual_df_rejected",
+    "design_named_contrast_aligned",
+    "design_zero_intercept_rejected",
+    "sanitize_dot_rejected",
+    "sanitize_collision_detected",
+]
+
+
+def run_rscript(args, cwd=None, check=True, timeout=1200):
+    cmd = [RSCRIPT] + [str(a) for a in args]
+    res = subprocess.run(cmd, cwd=cwd or ROOT, capture_output=True, text=True, timeout=timeout)
+    if check and res.returncode != 0:
+        raise AssertionError(
+            "Rscript failed with exit %d\nstdout:\n%s\nstderr:\n%s"
+            % (res.returncode, res.stdout[-3000:], res.stderr[-3000:])
+        )
+    return res
+
+
+@pytest.fixture(scope="module")
+def fixture_dir(tmp_path_factory):
+    out = tmp_path_factory.mktemp("postde_fixture")
+    res = run_rscript([FIXTURE, out])
+    assert "POSTDE_FIXTURE_OK" in res.stdout
+    return out
+
+
+@pytest.fixture(scope="module")
+def summary(fixture_dir):
+    with open(fixture_dir / "summary.json") as fh:
+        return json.load(fh)
+
+
+def test_fixture_runs_and_all_checks_pass(summary):
+    for key in REQUIRED_SUMMARY_CHECKS:
+        assert summary.get(key) is True, "summary check %s = %r" % (key, summary.get(key))
+    assert summary["diff_columns"] == "feature_id,score_difference,pvalue,padj,stat,mean_score,SE"
+    assert summary["gsea_rank_unavailable_status"] == "rank unavailable"
+    assert summary["dream_varpart_status"] == "error"
+    assert summary["dream_skipped_normalized"].startswith("skipped")
+    assert summary["gsva_max_diff"] < 1e-6
+    assert summary["diff_score_difference_max_diff"] < 1e-6
+    assert summary["diff_stat_max_diff"] < 1e-6
+    assert summary["ulm_max_diff"] < 1e-6
+    assert summary["mlm_max_diff"] < 1e-6
+    assert summary["dream_max_logfc_diff"] < 0.1
+    assert summary["gomap_expanded_rows"] > 4
+
+
+def test_bundles_written(fixture_dir):
+    assert (fixture_dir / "DE_deseq2_test_postde.rds").exists()
+    assert (fixture_dir / "DE_edger_test_postde.rds").exists()
+
+
+def test_empty_tsv_header_first(fixture_dir):
+    lines = (fixture_dir / "empty_result.tsv").read_text().splitlines()
+    assert lines[0] == "gene_id\tlogFC\tpvalue\tpadj\tstat\tmean"
+    status = json.loads((fixture_dir / "empty_result.tsv.status.json").read_text())
+    assert status["status"] == "no significant genes"
+
+
+def _write_config(path, data):
+    path.write_text(json.dumps(data))
+    return path
+
+
+def test_run_cli_end_to_end(fixture_dir, tmp_path):
+    config = {
+        "padj": 0.99,
+        "lfc": 0,
+        "min_size": 1,
+        "max_size": 500,
+        "seed": 1,
+        "clusterprofiler": {
+            "enabled": True,
+            "term2gene": str(fixture_dir / "term2gene.tsv"),
+            "term2name": str(fixture_dir / "term2name.tsv"),
+        },
+        "decoupler": {
+            "enabled": True,
+            "network": str(fixture_dir / "test_network.tsv"),
+            "min_size": 1,
+            "methods": ["ulm", "mlm"],
+        },
+    }
+    config_path = _write_config(tmp_path / "config.json", config)
+    out = tmp_path / "out"
+    res = run_rscript(
+        [
+            POSTDE_DIR / "run.R",
+            "--bundle",
+            fixture_dir / "DE_deseq2_test_postde.rds",
+            "--config",
+            config_path,
+            "--output",
+            out,
+        ]
+    )
+    assert res.returncode == 0
+    manifest = json.loads((out / "manifest.json").read_text())
+    assert manifest["output"] == "."
+    assert manifest["bundle_checksum"]
+    assert manifest["config_checksum"]
+    assert manifest["sessionInfo"]
+    entry = manifest["entries"]["A_vs_B"]
+    assert entry["dir"] == "A_vs_B"
+    assert entry["analyses"]["enrichment"]["enricher_all"]["result"] == "A_vs_B/enricher_all_result.tsv"
+    assert entry["analyses"]["regulatory"]["decoupler"]["ulm"]["activities"] == "A_vs_B/decoupler_ulm_activities.tsv"
+    assert (out / "A_vs_B" / "enricher_all_result.tsv").exists()
+    assert (out / "A_vs_B" / "decoupler_ulm_activities.tsv").exists()
+    assert (out / "A_vs_B" / "decoupler_mlm_activities.tsv").exists()
+    assert (out / "A_vs_B" / "gsea_result.tsv").exists()
+    assert (out / "report_data.rds").exists()
+
+
+def test_gprofiler_requires_allow_network(fixture_dir, tmp_path):
+    config = _write_config(
+        tmp_path / "config_gp.json",
+        {"gprofiler": {"enabled": True, "organism": "hsapiens"}},
+    )
+    res = run_rscript(
+        [
+            POSTDE_DIR / "run.R",
+            "--bundle",
+            fixture_dir / "DE_deseq2_test_postde.rds",
+            "--config",
+            config,
+            "--output",
+            tmp_path / "out_gp",
+        ],
+        check=False,
+    )
+    assert res.returncode != 0
+    assert "allow_network" in res.stderr
+
+
+def test_gprofiler_mock_injection(fixture_dir, tmp_path):
+    script = tmp_path / "mock_gprofiler.R"
+    template = """
+source("__COMMON__")
+source("__ENRICH__")
+mock_gost <- function(query, organism, domain_scope, sources, significant,
+                      user_threshold, correction_method, custom_bg = NULL) {
+    list(
+        result = data.frame(
+            query = "q1", significant = TRUE, p_value = 0.01,
+            term_size = 10, query_size = 5, intersection_size = 3,
+            effective_domain_size = 100, source = "GO:BP",
+            term_id = "GO:0006915", term_name = "apoptotic process",
+            parents = I(list(c("GO:0008150"))), stringsAsFactors = FALSE
+        ),
+        meta = list(version = "mock", organism = organism)
+    )
+}
+entry <- list(results = data.frame(
+    gene_id = paste0("g", 1:20), logFC = rnorm(20), pvalue = runif(20),
+    padj = runif(20), stat = rnorm(20), stringsAsFactors = FALSE))
+config <- list(padj = 0.5, lfc = 0,
+    gprofiler = list(enabled = TRUE, organism = "hsapiens",
+                     allow_network = TRUE, domain_scope = "custom",
+                     sources = list("GO:BP"), correction_method = "g_SCS"))
+out <- postde_run_gprofiler(entry, config, "__OUT__", gost_fun = mock_gost)
+stopifnot(out$all$status == "ok")
+stopifnot(file.exists(out$all$result))
+stopifnot(file.exists(out$all$meta))
+stopifnot(file.exists(out$all$raw))
+res <- read.delim(out$all$result, check.names = FALSE)
+stopifnot("term_id" %in% colnames(res))
+cat("MOCK_GPROFILER_OK\n")
+"""
+    script.write_text(
+        template.replace("__COMMON__", str(POSTDE_DIR / "common.R"))
+        .replace("__ENRICH__", str(POSTDE_DIR / "enrichment.R"))
+        .replace("__OUT__", str(tmp_path))
+    )
+    res = run_rscript([script])
+    assert "MOCK_GPROFILER_OK" in res.stdout
+
+
+def test_config_validation_rejects_bad_padj(fixture_dir, tmp_path):
+    config = _write_config(tmp_path / "config_bad.json", {"padj": 1.5})
+    res = run_rscript(
+        [
+            POSTDE_DIR / "run.R",
+            "--bundle",
+            fixture_dir / "DE_deseq2_test_postde.rds",
+            "--config",
+            config,
+            "--output",
+            tmp_path / "out_bad",
+        ],
+        check=False,
+    )
+    assert res.returncode != 0
+    assert "padj" in res.stderr
+
+
+def test_empty_bundle_rejected(tmp_path):
+    bundle = tmp_path / "empty_bundle.rds"
+    res = run_rscript(
+        [
+            "-e",
+            "saveRDS(list(schema_version = 1L, engine = 'test', contrasts = list()), '%s')" % bundle,
+        ]
+    )
+    assert res.returncode == 0
+    config = _write_config(tmp_path / "config_empty.json", {})
+    res = run_rscript(
+        [
+            POSTDE_DIR / "run.R",
+            "--bundle",
+            bundle,
+            "--config",
+            config,
+            "--output",
+            tmp_path / "out_empty",
+        ],
+        check=False,
+    )
+    assert res.returncode != 0
+    assert "no contrast entries" in res.stderr
+
+
+def test_duplicate_sanitized_ids_rejected(tmp_path):
+    bundle = tmp_path / "dup_bundle.rds"
+    script = tmp_path / "make_dup_bundle.R"
+    entry_r = (
+        "list(id = 'a/b', A = 'A', B = 'B', normalized = FALSE, metadata = list(), "
+        "counts = list(), expression = list(), design = list(), contrast = list(), "
+        "results = list(), mean_scale = 'baseMean')"
+    )
+    script.write_text(
+        "saveRDS(list(schema_version = 1L, engine = 'test', "
+        "contrasts = list(e1 = %s, e2 = %s)), '%s')\n" % (entry_r, entry_r, bundle)
+    )
+    res = run_rscript([script])
+    assert res.returncode == 0
+    config = _write_config(tmp_path / "config_dup.json", {})
+    res = run_rscript(
+        [
+            POSTDE_DIR / "run.R",
+            "--bundle",
+            bundle,
+            "--config",
+            config,
+            "--output",
+            tmp_path / "out_dup",
+        ],
+        check=False,
+    )
+    assert res.returncode != 0
+    assert "duplicate" in res.stderr.lower() or "unsafe" in res.stderr.lower()

From a81653d0af09406205d16ba500f9f4d10d1a24b7 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 11:09:33 +0200
Subject: [PATCH 62/80] more postDE wip

---
 MONSDA/PostDE.py               | 339 ++++++++++++++++++++++++
 MONSDA/RunMONSDA.py            |  10 +-
 MONSDA/Workflows.py            |  29 ++
 tests/test_postde_workflows.py | 468 +++++++++++++++++++++++++++++++++
 workflows/deseq2_DE.nf         |  37 ++-
 workflows/deseq2_DE.smk        |  25 +-
 workflows/edger_DE.nf          |  37 ++-
 workflows/edger_DE.smk         |  25 +-
 8 files changed, 961 insertions(+), 9 deletions(-)
 create mode 100644 MONSDA/PostDE.py
 create mode 100644 tests/test_postde_workflows.py

diff --git a/MONSDA/PostDE.py b/MONSDA/PostDE.py
new file mode 100644
index 00000000..20c683c4
--- /dev/null
+++ b/MONSDA/PostDE.py
@@ -0,0 +1,339 @@
+import hashlib
+import json
+import os
+import shutil
+
+POSTDE_SECTION_KEYS = frozenset({"enabled", "config"})
+POSTDE_TOP_KEYS = frozenset(
+    {
+        "padj",
+        "lfc",
+        "seed",
+        "min_size",
+        "max_size",
+        "gprofiler",
+        "clusterprofiler",
+        "gsva",
+        "decoupler",
+        "dream",
+        "plots",
+        "report",
+        "shiny",
+    }
+)
+POSTDE_METHOD_KEYS = {
+    "gprofiler": frozenset(
+        {
+            "enabled",
+            "organism",
+            "domain_scope",
+            "allow_network",
+            "sources",
+            "correction_method",
+            "background",
+        }
+    ),
+    "clusterprofiler": frozenset(
+        {"enabled", "term2gene", "term2name", "go_expand", "background"}
+    ),
+    "gsva": frozenset({"enabled", "method", "min_size", "max_size"}),
+    "decoupler": frozenset(
+        {
+            "enabled",
+            "network",
+            "source_col",
+            "target_col",
+            "mor_col",
+            "allow_network",
+            "resource",
+            "organism",
+            "top",
+            "min_size",
+            "methods",
+            "contrast_activity",
+        }
+    ),
+    "dream": frozenset({"enabled", "metadata", "formula", "contrasts"}),
+    "plots": frozenset({"enabled"}),
+    "report": frozenset({"enabled"}),
+    "shiny": frozenset({"enabled"}),
+}
+POSTDE_RESOURCE_KEYS = {
+    "gprofiler": ("background",),
+    "clusterprofiler": ("term2gene", "term2name", "background"),
+    "decoupler": ("network",),
+    "dream": ("metadata",),
+}
+POSTDE_SUPPORTED_DE_TOOLS = frozenset({"deseq2", "edger"})
+POSTDE_DOMAIN_SCOPES = ("annotated", "known", "custom", "custom_annotated")
+POSTDE_CORRECTION_METHODS = (
+    "g_SCS",
+    "bonferroni",
+    "fdr",
+    "false_discovery_rate",
+    "gSCS",
+    "analytical",
+)
+POSTDE_GSVA_METHODS = ("gsva", "ssgsea")
+POSTDE_DECOUPLER_RESOURCES = ("collectri", "progeny")
+POSTDE_DECOUPLER_METHODS = ("ulm", "mlm")
+
+
+def _is_number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _validate_analysis_config(analysis, base_dir):
+    unknown = set(analysis) - POSTDE_TOP_KEYS
+    if unknown:
+        raise ValueError(
+            "POSTDE config has unknown top-level fields: "
+            + ", ".join(sorted(unknown))
+        )
+    if "padj" in analysis and (
+        not _is_number(analysis["padj"]) or not 0 < analysis["padj"] < 1
+    ):
+        raise ValueError("POSTDE config padj must be numeric in (0, 1)")
+    if "lfc" in analysis and (
+        not _is_number(analysis["lfc"]) or analysis["lfc"] < 0
+    ):
+        raise ValueError("POSTDE config lfc must be numeric >= 0")
+    if "seed" in analysis and not _is_number(analysis["seed"]):
+        raise ValueError("POSTDE config seed must be numeric")
+    if "min_size" in analysis and (
+        not _is_number(analysis["min_size"]) or analysis["min_size"] < 1
+    ):
+        raise ValueError("POSTDE config min_size must be numeric >= 1")
+    if "max_size" in analysis and (
+        not _is_number(analysis["max_size"])
+        or analysis["max_size"] < analysis.get("min_size", 1)
+    ):
+        raise ValueError("POSTDE config max_size must be numeric >= min_size")
+    for method, keys in POSTDE_METHOD_KEYS.items():
+        sub = analysis.get(method)
+        if sub is None:
+            continue
+        if not isinstance(sub, dict):
+            raise ValueError("POSTDE config " + method + " must be an object")
+        unknown = set(sub) - keys
+        if unknown:
+            raise ValueError(
+                "POSTDE config "
+                + method
+                + " has unknown fields: "
+                + ", ".join(sorted(unknown))
+            )
+        if "enabled" in sub and not isinstance(sub["enabled"], bool):
+            raise ValueError(
+                "POSTDE config " + method + ".enabled must be a boolean"
+            )
+    for vis in ("plots", "report", "shiny"):
+        if analysis.get(vis, {}).get("enabled"):
+            raise ValueError(
+                "POSTDE config "
+                + vis
+                + ".enabled=true is not available (reporting.R not yet provided)"
+            )
+    gp = analysis.get("gprofiler", {})
+    if gp.get("enabled"):
+        if not isinstance(gp.get("organism"), str) or not gp["organism"].strip():
+            raise ValueError(
+                "POSTDE config gprofiler.enabled=true requires gprofiler.organism"
+            )
+        if not gp.get("allow_network"):
+            raise ValueError(
+                "POSTDE config gprofiler.enabled=true requires gprofiler.allow_network=true"
+            )
+        if "domain_scope" in gp and gp["domain_scope"] not in POSTDE_DOMAIN_SCOPES:
+            raise ValueError(
+                "POSTDE config gprofiler.domain_scope must be one of "
+                + ", ".join(POSTDE_DOMAIN_SCOPES)
+            )
+        if "correction_method" in gp and gp[
+            "correction_method"
+        ] not in POSTDE_CORRECTION_METHODS:
+            raise ValueError(
+                "POSTDE config gprofiler.correction_method must be one of "
+                + ", ".join(POSTDE_CORRECTION_METHODS)
+            )
+    cp = analysis.get("clusterprofiler", {})
+    gs = analysis.get("gsva", {})
+    if (cp.get("enabled") or gs.get("enabled")) and not cp.get("term2gene"):
+        raise ValueError(
+            "POSTDE config clusterprofiler.term2gene required when clusterprofiler/gsva enabled"
+        )
+    if "method" in gs and gs["method"] not in POSTDE_GSVA_METHODS:
+        raise ValueError(
+            "POSTDE config gsva.method must be one of " + ", ".join(POSTDE_GSVA_METHODS)
+        )
+    if "min_size" in gs and (
+        not _is_number(gs["min_size"]) or gs["min_size"] < 1
+    ):
+        raise ValueError("POSTDE config gsva.min_size must be numeric >= 1")
+    if "max_size" in gs and (
+        not _is_number(gs["max_size"])
+        or gs["max_size"] < gs.get("min_size", analysis.get("min_size", 1))
+    ):
+        raise ValueError("POSTDE config gsva.max_size must be numeric >= min_size")
+    dc = analysis.get("decoupler", {})
+    if dc.get("enabled"):
+        if not dc.get("network") and not dc.get("allow_network"):
+            raise ValueError(
+                "POSTDE config decoupler.enabled=true requires decoupler.network or decoupler.allow_network=true"
+            )
+        if "resource" in dc and dc["resource"] not in POSTDE_DECOUPLER_RESOURCES:
+            raise ValueError(
+                "POSTDE config decoupler.resource must be one of "
+                + ", ".join(POSTDE_DECOUPLER_RESOURCES)
+            )
+        if "methods" in dc:
+            methods = (
+                dc["methods"] if isinstance(dc["methods"], list) else [dc["methods"]]
+            )
+            if not methods or any(
+                m not in POSTDE_DECOUPLER_METHODS for m in methods
+            ):
+                raise ValueError(
+                    "POSTDE config decoupler.methods must be a list of "
+                    + ", ".join(POSTDE_DECOUPLER_METHODS)
+                )
+        if "min_size" in dc and (
+            not _is_number(dc["min_size"]) or dc["min_size"] < 1
+        ):
+            raise ValueError("POSTDE config decoupler.min_size must be numeric >= 1")
+        if "top" in dc and (not _is_number(dc["top"]) or dc["top"] < 1):
+            raise ValueError("POSTDE config decoupler.top must be numeric >= 1")
+    dm = analysis.get("dream", {})
+    if dm.get("enabled"):
+        if not isinstance(dm.get("metadata"), str) or not dm["metadata"].strip():
+            raise ValueError(
+                "POSTDE config dream.enabled=true requires dream.metadata"
+            )
+        if not isinstance(dm.get("formula"), str) or not dm["formula"].strip():
+            raise ValueError("POSTDE config dream.enabled=true requires dream.formula")
+    for method, keys in POSTDE_RESOURCE_KEYS.items():
+        sub = analysis.get(method, {})
+        for key in keys:
+            path = sub.get(key)
+            if path is None:
+                continue
+            if not isinstance(path, str) or not path.strip():
+                raise ValueError(
+                    "POSTDE config " + method + "." + key + " must be a non-empty path"
+                )
+            full = path if os.path.isabs(path) else os.path.join(base_dir, path)
+            if not os.path.isfile(full):
+                raise ValueError(
+                    "POSTDE config resource file not found: "
+                    + method
+                    + "."
+                    + key
+                    + " -> "
+                    + full
+                )
+
+
+def load_postde_config(section, config=None):
+    if section is None:
+        return None
+    if not isinstance(section, dict):
+        raise ValueError("POSTDE section must be an object")
+    unknown = set(section) - POSTDE_SECTION_KEYS
+    if unknown:
+        raise ValueError(
+            "POSTDE section has unknown fields: " + ", ".join(sorted(unknown))
+        )
+    if "enabled" not in section:
+        raise ValueError("POSTDE section missing required field 'enabled'")
+    if not isinstance(section["enabled"], bool):
+        raise ValueError("POSTDE.enabled must be a boolean")
+    if not section["enabled"]:
+        return {"enabled": False, "config": section.get("config", "")}
+    if not isinstance(section.get("config"), str) or not section["config"].strip():
+        raise ValueError("POSTDE.enabled=true requires a non-empty POSTDE.config path")
+    config_path = os.path.abspath(section["config"])
+    if not os.path.isfile(config_path):
+        raise ValueError("POSTDE.config file not found: " + config_path)
+    try:
+        with open(config_path) as fh:
+            analysis = json.load(fh)
+    except (OSError, ValueError) as err:
+        raise ValueError("POSTDE.config is not readable JSON: " + str(err))
+    if not isinstance(analysis, dict):
+        raise ValueError("POSTDE.config must contain a JSON object")
+    _validate_analysis_config(analysis, os.path.dirname(config_path))
+    if config is not None:
+        workflows = [
+            w.strip()
+            for w in str(config.get("WORKFLOWS", "")).split(",")
+            if w.strip()
+        ]
+        if "DE" not in workflows:
+            raise ValueError("POSTDE.enabled=true requires DE in WORKFLOWS")
+        de_tools = config.get("DE", {}).get("TOOLS", {})
+        if isinstance(de_tools, dict):
+            unsupported = set(de_tools) - POSTDE_SUPPORTED_DE_TOOLS
+            if unsupported:
+                raise ValueError(
+                    "POSTDE.enabled=true does not support DE tools: "
+                    + ", ".join(sorted(unsupported))
+                )
+    return {"enabled": True, "config": config_path}
+
+
+def _collect_resources(analysis, base_dir):
+    resources = []
+    for method, keys in POSTDE_RESOURCE_KEYS.items():
+        sub = analysis.get(method, {})
+        for key in keys:
+            path = sub.get(key)
+            if path is None:
+                continue
+            full = path if os.path.isabs(path) else os.path.join(base_dir, path)
+            resources.append((method, key, full))
+    return resources
+
+
+def _staged_names(resources):
+    by_basename = {}
+    for method, key, full in resources:
+        by_basename.setdefault(os.path.basename(full), []).append((method, key, full))
+    names = {}
+    for bn, items in by_basename.items():
+        if len(items) == 1:
+            names[(items[0][0], items[0][1])] = bn
+        else:
+            for method, key, full in items:
+                names[(method, key)] = key + "_" + bn
+    return names
+
+
+def prepare_postde(config, subdir):
+    section = load_postde_config(config.get("POSTDE"), config=config)
+    if section is None or not section.get("enabled"):
+        return None
+    config_path = section["config"]
+    with open(config_path) as fh:
+        analysis = json.load(fh)
+    base_dir = os.path.dirname(config_path)
+    resources = _collect_resources(analysis, base_dir)
+    digest = hashlib.sha256()
+    digest.update(json.dumps(analysis, sort_keys=True).encode("utf-8"))
+    for method, key, full in sorted(resources):
+        with open(full, "rb") as fh:
+            digest.update(fh.read())
+    staged = os.path.join(subdir, "POSTDE_" + digest.hexdigest()[:12])
+    if os.path.isdir(staged) and os.path.isfile(os.path.join(staged, "config.json")):
+        return staged
+    os.makedirs(staged, exist_ok=True)
+    names = _staged_names(resources)
+    for method, key, full in resources:
+        dst = os.path.join(staged, names[(method, key)])
+        if not os.path.exists(dst) or not shutil.cmp(full, dst):
+            shutil.copy2(full, dst)
+    staged_analysis = json.loads(json.dumps(analysis))
+    for method, key, full in resources:
+        staged_analysis[method][key] = names[(method, key)]
+    with open(os.path.join(staged, "config.json"), "w") as fh:
+        json.dump(staged_analysis, fh, indent=2)
+    return staged
diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index 8ff7d41f..655cbb78 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -1007,7 +1007,8 @@ def main():
             + "{}".format(" ".join([shlex.quote(s) for s in sys.argv[1:]]))
         )
 
-        required_version = load_configfile(knownargs.configfile).get("VERSION")
+        config = load_configfile(knownargs.configfile)
+        required_version = config.get("VERSION")
         if not required_version:
             sys.exit(
                 "Can not check version needed, please add VERSION key to config file"
@@ -1031,6 +1032,13 @@ def main():
         else:
             log.info("Running MONSDA version " + __version__ + " as configured")
 
+        postde_section = config.get("POSTDE")
+        if postde_section and postde_section.get("enabled"):
+            try:
+                mw.load_postde_config(postde_section, config=config)
+            except ValueError as err:
+                sys.exit("POSTDE config invalid: " + str(err))
+
         MIN_PYTHON = (3, 11)
         if sys.version_info < MIN_PYTHON:
             log.error("This script requires Python version >= 3.7")
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index d13516ef..2cdaa458 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -38,6 +38,7 @@
 import MONSDA.Params as mp
 import MONSDA.Utils as mu
 from MONSDA.Containers import normalize_container_version
+from MONSDA.PostDE import load_postde_config, prepare_postde
 from MONSDA.Utils import check_run as check_run
 from MONSDA.Utils import dump_if_different, write_if_different
 
@@ -698,6 +699,9 @@ def create_subworkflow(config, subwork, conditions, envs=None, stage=None):
             )
             log.error("".join(tbe.format()))
 
+        if config.get("POSTDE", {}).get("enabled") and subwork == "DE":
+            tempconf["POSTDE"] = config["POSTDE"]
+
         (
             configs.append(tempconf)
             if tempconf.get("SETTINGS", False)
@@ -1328,6 +1332,16 @@ def make_post(
 
     log.debug(logid + f"STARTING POSTPROCESSING {postworkflow} FOR {conditions}")
 
+    if postworkflow == "DE":
+        postde_inputs = prepare_postde(config, subdir)
+        if postde_inputs:
+            config = dict(config)
+            config["POSTDE"] = {
+                "enabled": True,
+                "config": config["POSTDE"]["config"],
+                "inputs": postde_inputs,
+            }
+
     jobs = list()
     condapath = re.compile(r'conda:\s+"')
     logfix = re.compile(r'loglevel="INFO"')
@@ -2277,6 +2291,11 @@ def nf_fetch_params(
             "INDEX", ""
         ) or os.path.join(REFDIR, "CTAT", FUSENV)
 
+    postde = config.get("POSTDE")
+    if postde and postde.get("enabled"):
+        retconf["POSTDE_ENABLED"] = True
+        retconf["POSTDE_INPUTS"] = postde.get("inputs", "")
+
     retconf["REFERENCE"] = REFERENCE
     retconf["REFDIR"] = REFDIR
     retconf["IP"] = IP
@@ -3463,6 +3482,16 @@ def nf_make_post(
 
     log.debug(logid + f"STARTING POSTPROCESSING {postworkflow} FOR {conditions}")
 
+    if postworkflow == "DE":
+        postde_inputs = prepare_postde(config, subdir)
+        if postde_inputs:
+            config = dict(config)
+            config["POSTDE"] = {
+                "enabled": True,
+                "config": config["POSTDE"]["config"],
+                "inputs": postde_inputs,
+            }
+
     jobs = list()
     condapath = re.compile(r'conda\s+"')
     includepath = re.compile(r'include:\s+"')
diff --git a/tests/test_postde_workflows.py b/tests/test_postde_workflows.py
new file mode 100644
index 00000000..8a7c84ff
--- /dev/null
+++ b/tests/test_postde_workflows.py
@@ -0,0 +1,468 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("snakemake")
+
+from snakemake.common.configfile import load_configfile  # noqa: E402
+
+import MONSDA.Params as mp  # noqa: E402
+import MONSDA.Workflows as mw  # noqa: E402
+from MONSDA.PostDE import load_postde_config, prepare_postde  # noqa: E402
+
+REPO = Path(__file__).resolve().parents[1]
+DATA = REPO / "tests" / "data"
+
+
+@pytest.fixture(autouse=True)
+def _repo_template_paths(monkeypatch):
+    old_wf, old_env, old_bin = mw.workflowpath, mw.envpath, mw.binpath
+    mw.workflowpath = str(REPO / "workflows")
+    mw.envpath = str(REPO / "envs") + os.sep
+    mw.binpath = str(REPO / "scripts")
+    monkeypatch.setattr(
+        mw, "normalize_container_version", lambda version=None: "VERSION"
+    )
+    yield
+    mw.workflowpath, mw.envpath, mw.binpath = old_wf, old_env, old_bin
+
+
+def _load(name):
+    return load_configfile(str(DATA / name))
+
+
+@pytest.fixture
+def workdir(tmp_path):
+    for item in os.listdir(DATA):
+        os.symlink(DATA / item, tmp_path / item)
+    old = os.getcwd()
+    os.chdir(tmp_path)
+    try:
+        yield tmp_path
+    finally:
+        os.chdir(old)
+
+
+def _analysis_config(tmp_path, analysis, name="postde_analysis.json"):
+    path = tmp_path / name
+    path.write_text(json.dumps(analysis))
+    return path
+
+
+def _postde_cfg(tmp_path, analysis, workflows="DE", tools=None):
+    cfg = _load("config_Test.json")
+    cfg["WORKFLOWS"] = workflows
+    if tools is not None:
+        cfg["DE"]["TOOLS"] = tools
+    cfg["POSTDE"] = {
+        "enabled": True,
+        "config": str(_analysis_config(tmp_path, analysis)),
+    }
+    return cfg
+
+
+def _generate_de(engine, workdir, cfg):
+    conditions = mp.get_conditions(cfg)
+    samples = mp.get_samples_postprocess(cfg, "DE")
+    if engine == "smk":
+        subdir = "SubSnakes"
+        mp.create_skeleton(subdir, None)
+        mw.make_post("DE", cfg, samples, conditions, subdir, "INFO")
+    else:
+        subdir = "SubFlows"
+        mp.create_skeleton(subdir, None)
+        mw.nf_make_post("DE", cfg, samples, conditions, subdir, "INFO")
+    return subdir
+
+
+def _extract_nf_script(subflow, process_name):
+    match = re.search(r"process\s+" + process_name + r"\s*\{", subflow)
+    assert match, f"process {process_name} not found in generated subflow"
+    start = match.end()
+    depth = 1
+    i = start
+    while i < len(subflow) and depth > 0:
+        if subflow[i] == "{":
+            depth += 1
+        elif subflow[i] == "}":
+            depth -= 1
+        i += 1
+    body = subflow[start:i]
+    block = re.search(r'script:\s*"""\n(.*?)\n\s*"""', body, re.S)
+    assert block, f"script block not found in process {process_name}"
+    return block.group(1)
+
+
+def _write_stub_bundle(rscript, path):
+    rcode = (
+        'bundle <- list(schema_version = 1L, engine = "deseq2", '
+        'contrasts = list(list(id = "T1-VS-T2")))\n'
+        "saveRDS(bundle, commandArgs(trailingOnly = TRUE)[1])\n"
+    )
+    rfile = path.with_suffix(".R")
+    rfile.write_text(rcode)
+    subprocess.run(
+        [rscript, str(rfile), str(path)], check=True, capture_output=True
+    )
+
+
+class TestLoadPostdeConfig:
+    def test_none_returns_none(self):
+        assert load_postde_config(None) is None
+
+    def test_disabled_returns_section(self):
+        section = {"enabled": False, "config": ""}
+        assert load_postde_config(section) == section
+
+    def test_missing_enabled_raises(self):
+        with pytest.raises(ValueError, match="enabled"):
+            load_postde_config({"config": ""})
+
+    def test_enabled_nonbool_raises(self):
+        with pytest.raises(ValueError, match="boolean"):
+            load_postde_config({"enabled": "yes", "config": ""})
+
+    def test_unknown_section_field_raises(self):
+        with pytest.raises(ValueError, match="unknown fields"):
+            load_postde_config({"enabled": False, "config": "", "enabeld": True})
+
+    def test_enabled_missing_config_raises(self):
+        with pytest.raises(ValueError, match="config"):
+            load_postde_config({"enabled": True})
+
+    def test_config_not_found_raises(self):
+        with pytest.raises(ValueError, match="not found"):
+            load_postde_config({"enabled": True, "config": "nope.json"})
+
+    def test_config_invalid_json_raises(self, tmp_path):
+        path = tmp_path / "bad.json"
+        path.write_text("not json")
+        with pytest.raises(ValueError, match="JSON"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_unknown_analysis_field_raises(self, tmp_path):
+        path = _analysis_config(tmp_path, {"gprofilerr": {"enabled": True}})
+        with pytest.raises(ValueError, match="unknown top-level"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_plots_enabled_raises(self, tmp_path):
+        path = _analysis_config(tmp_path, {"plots": {"enabled": True}})
+        with pytest.raises(ValueError, match="not available"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_gprofiler_requires_organism(self, tmp_path):
+        path = _analysis_config(
+            tmp_path, {"gprofiler": {"enabled": True, "allow_network": True}}
+        )
+        with pytest.raises(ValueError, match="organism"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_gprofiler_requires_allow_network(self, tmp_path):
+        path = _analysis_config(
+            tmp_path, {"gprofiler": {"enabled": True, "organism": "hsapiens"}}
+        )
+        with pytest.raises(ValueError, match="allow_network"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_decoupler_requires_network_or_allow_network(self, tmp_path):
+        path = _analysis_config(tmp_path, {"decoupler": {"enabled": True}})
+        with pytest.raises(ValueError, match="allow_network"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_missing_resource_raises(self, tmp_path):
+        path = _analysis_config(
+            tmp_path,
+            {"clusterprofiler": {"enabled": True, "term2gene": "missing.tsv"}},
+        )
+        with pytest.raises(ValueError, match="resource file not found"):
+            load_postde_config({"enabled": True, "config": str(path)})
+
+    def test_valid_returns_abs_config(self, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        path = _analysis_config(tmp_path, analysis)
+        out = load_postde_config({"enabled": True, "config": str(path)})
+        assert out["enabled"] is True
+        assert out["config"] == str(path.resolve())
+
+    def test_no_de_in_workflows_raises(self, tmp_path):
+        cfg = _postde_cfg(tmp_path, {}, workflows="QC")
+        with pytest.raises(ValueError, match="DE in WORKFLOWS"):
+            load_postde_config(cfg["POSTDE"], config=cfg)
+
+    def test_unsupported_de_tool_raises(self, tmp_path):
+        cfg = _postde_cfg(
+            tmp_path, {}, tools={"diego": "Analysis/DE/DIEGO.R"}
+        )
+        with pytest.raises(ValueError, match="does not support"):
+            load_postde_config(cfg["POSTDE"], config=cfg)
+
+
+class TestPreparePostde:
+    def test_disabled_returns_none(self, tmp_path):
+        cfg = _load("config_Test.json")
+        cfg["POSTDE"] = {"enabled": False, "config": ""}
+        assert prepare_postde(cfg, "SubSnakes") is None
+        assert not (tmp_path / "SubSnakes").exists()
+
+    def test_no_postde_returns_none(self, tmp_path):
+        cfg = _load("config_Test.json")
+        assert prepare_postde(cfg, "SubSnakes") is None
+
+    def test_stages_config_and_resources(self, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        (tmp_path / "term2name.tsv").write_text("term\tname\nGO:1\tName1\n")
+        analysis = {
+            "padj": 0.05,
+            "clusterprofiler": {
+                "enabled": True,
+                "term2gene": "term2gene.tsv",
+                "term2name": "term2name.tsv",
+            },
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged = prepare_postde(cfg, "SubSnakes")
+        assert staged is not None
+        assert staged.startswith("SubSnakes" + os.sep + "POSTDE_")
+        assert os.path.isfile(os.path.join(staged, "config.json"))
+        assert os.path.isfile(os.path.join(staged, "term2gene.tsv"))
+        assert os.path.isfile(os.path.join(staged, "term2name.tsv"))
+        staged_cfg = json.load(open(os.path.join(staged, "config.json")))
+        assert staged_cfg["clusterprofiler"]["term2gene"] == "term2gene.tsv"
+        assert staged_cfg["clusterprofiler"]["term2name"] == "term2name.tsv"
+
+    def test_relative_resource_paths(self, tmp_path):
+        resdir = tmp_path / "res"
+        resdir.mkdir()
+        (resdir / "background.tsv").write_text("G1\n")
+        analysis = {
+            "gprofiler": {
+                "enabled": True,
+                "organism": "hsapiens",
+                "allow_network": True,
+                "background": "res/background.tsv",
+            }
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged = prepare_postde(cfg, "SubSnakes")
+        assert os.path.isfile(os.path.join(staged, "background.tsv"))
+
+    def test_duplicate_basenames(self, tmp_path):
+        (tmp_path / "background.tsv").write_text("G1\n")
+        resdir = tmp_path / "res"
+        resdir.mkdir()
+        (resdir / "background.tsv").write_text("G2\n")
+        analysis = {
+            "gprofiler": {
+                "enabled": True,
+                "organism": "hsapiens",
+                "allow_network": True,
+                "background": "background.tsv",
+            },
+            "clusterprofiler": {
+                "enabled": True,
+                "term2gene": "res/background.tsv",
+            },
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged = prepare_postde(cfg, "SubSnakes")
+        names = sorted(os.listdir(staged))
+        assert "background.tsv" in names
+        assert "term2gene_background.tsv" in names
+
+    def test_content_change_new_dir(self, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged1 = prepare_postde(cfg, "SubSnakes")
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG2\n")
+        staged2 = prepare_postde(cfg, "SubSnakes")
+        assert staged1 != staged2
+
+    def test_reuse_existing_dir(self, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged1 = prepare_postde(cfg, "SubSnakes")
+        mtime1 = os.path.getmtime(os.path.join(staged1, "config.json"))
+        staged2 = prepare_postde(cfg, "SubSnakes")
+        assert staged1 == staged2
+        assert os.path.getmtime(os.path.join(staged2, "config.json")) == mtime1
+
+
+class TestWorkflowIntegration:
+    def test_make_post_smk(self, workdir, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        subdir = _generate_de("smk", workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
+        )
+        assert confo["POSTDE"]["enabled"] is True
+        assert confo["POSTDE"]["inputs"].startswith("SubSnakes" + os.sep + "POSTDE_")
+        smk = (workdir / subdir / "allconditions_DE_deseq2_subsnake.smk").read_text()
+        assert "rule postde" in smk
+        assert "MONSDA_POSTDE={postde_flag}" in smk
+        assert "DE_deseq2_{scombo}_postde.rds" in smk
+        assert "POSTDE/{combo}/manifest.json" in smk
+        smk_e = (workdir / subdir / "allconditions_DE_edger_subsnake.smk").read_text()
+        assert "rule postde" in smk_e
+        assert "DE_edger_{scombo}_postde.rds" in smk_e
+
+    def test_make_post_nf(self, workdir, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        subdir = _generate_de("nf", workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
+        )
+        assert confo["POSTDE"]["enabled"] is True
+        assert confo["POSTDE"]["inputs"].startswith("SubFlows" + os.sep + "POSTDE_")
+        nf = (workdir / subdir / "allconditions_DE_deseq2_subflow.nf").read_text()
+        assert "process postde" in nf
+        assert "MONSDA_POSTDE=${params.gPOSTDE_FLAG}" in nf
+        assert "emit: bundle, optional: true" in nf
+        assert "postde(run_deseq2.out.bundle" in nf
+        nf_e = (workdir / subdir / "allconditions_DE_edger_subflow.nf").read_text()
+        assert "process postde" in nf_e
+        assert "postde(run_edger.out.bundle" in nf_e
+
+    def test_disabled_no_postde(self, workdir, tmp_path):
+        cfg = _load("config_Test.json")
+        cfg["POSTDE"] = {"enabled": False, "config": ""}
+        subdir = _generate_de("smk", workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
+        )
+        assert "POSTDE" not in confo
+        smk = (workdir / subdir / "allconditions_DE_deseq2_subsnake.smk").read_text()
+        assert "rule postde" not in smk
+        assert "MONSDA_POSTDE=0" in smk
+
+    def test_snakemake_dag_dryrun(self, workdir, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"}
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        subdir = _generate_de("smk", workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
+        )
+        bundle = workdir / "DE" / "deseq2_DE" / "DE_deseq2__postde.rds"
+        bundle.parent.mkdir(parents=True, exist_ok=True)
+        bundle.write_bytes(b"fake")
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "snakemake",
+                "-n",
+                "-s",
+                str(workdir / subdir / "allconditions_DE_deseq2_subsnake.smk"),
+                "--configfile",
+                str(workdir / subdir / "allconditions_DE_deseq2_subconfig.json"),
+                "--directory",
+                str(workdir),
+                "POSTDE/deseq2_DE/manifest.json",
+            ],
+            capture_output=True,
+            text=True,
+            env={**os.environ, "PYTHONPATH": str(REPO)},
+        )
+        assert result.returncode == 0, result.stderr[-2000:]
+        assert "postde" in result.stdout
+
+
+class TestNfProcessBody:
+    def test_postde_process_body_runs(self, workdir, tmp_path):
+        rscript = shutil.which("Rscript")
+        if not rscript:
+            pytest.skip("Rscript not found on PATH")
+        analysis = {"padj": 0.05, "lfc": 1}
+        cfg = _postde_cfg(tmp_path, analysis)
+        subdir = _generate_de("nf", workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
+        )
+        staged = confo["POSTDE"]["inputs"]
+        subflow = (workdir / subdir / "allconditions_DE_deseq2_subflow.nf").read_text()
+        script = _extract_nf_script(subflow, "postde")
+        bundle = workdir / "DE" / "deseq2_DE" / "DE_deseq2__postde.rds"
+        bundle.parent.mkdir(parents=True, exist_ok=True)
+        _write_stub_bundle(rscript, bundle)
+        outdir = workdir / "postde_out"
+        script = script.replace("${params.gBINS}", str(REPO / "scripts"))
+        script = script.replace("postde_inputs", str(workdir / staged))
+        script = script.replace("../bundle", str(bundle))
+        script = script.replace("../postde", str(outdir))
+        result = subprocess.run(
+            script, shell=True, cwd=str(workdir), capture_output=True, text=True
+        )
+        assert result.returncode == 0, result.stderr[-2000:]
+        assert (outdir / "manifest.json").exists()
+
+
+class TestCliSave:
+    def test_cli_save_generates_postde(self, tmp_path):
+        for item in ("FASTQ", "GENOME"):
+            os.symlink(DATA / item, tmp_path / item)
+        (tmp_path / "sitecustomize.py").write_text(
+            "import MONSDA.Workflows as mw\n"
+            f"mw.workflowpath = {str(REPO / 'workflows')!r}\n"
+            f"mw.envpath = {str(REPO / 'envs') + os.sep!r}\n"
+            f"mw.binpath = {str(REPO / 'scripts')!r}\n"
+        )
+        from MONSDA import _version
+
+        version = _version.get_versions()["version"]
+        cfg = _load("config_Test.json")
+        cfg["VERSION"] = version
+        cfg["WORKFLOWS"] = "DE"
+        cfg["POSTDE"] = {
+            "enabled": True,
+            "config": str(_analysis_config(tmp_path, {"padj": 0.05, "lfc": 1})),
+        }
+        (tmp_path / "config_Test.json").write_text(json.dumps(cfg))
+        env = {**os.environ, "PYTHONPATH": str(REPO) + os.pathsep + str(tmp_path)}
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "MONSDA.RunMONSDA",
+                "--save",
+                "-c",
+                "config_Test.json",
+            ],
+            cwd=str(tmp_path),
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        assert result.returncode == 0, result.stderr[-2000:]
+        subdir = tmp_path / "SubSnakes"
+        confo = json.load(open(subdir / "allconditions_DE_deseq2_subconfig.json"))
+        assert confo["POSTDE"]["enabled"] is True
+        staged = confo["POSTDE"]["inputs"]
+        assert (tmp_path / staged / "config.json").exists()
+        commands = (tmp_path / "JOBS" / "MONSDA.commands").read_text()
+        assert "allconditions_DE_deseq2_subsnake.smk" in commands
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 55660ae8..c53128fd 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -11,6 +11,9 @@ DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
 PCOMBO = get_always('COMBO') ?: 'none'
+POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
+POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
+POSTDE_FLAG = POSTDE_ENABLED ? '1' : '0'
 
 COUNTBIN = 'featureCounts'
 COUNTENV = 'countreads_de'
@@ -111,6 +114,7 @@ process run_deseq2{
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DE/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("_postde") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"
         else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/run_deseq2.log"
     }
 
@@ -125,6 +129,7 @@ process run_deseq2{
     path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
+    path "*_postde.rds", emit: bundle, optional: true
     path "log", emit: log
 
     script:    
@@ -132,7 +137,7 @@ process run_deseq2{
     bin = "${BINS}"+File.separatorChar+"${DEBIN}"
     """
     mkdir -p Figures Tables
-    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    MONSDA_POSTDE=${POSTDE_FLAG} Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
     """
 }
 
@@ -205,6 +210,32 @@ process collect_deseq{
     """
 }
 
+process postde{
+    conda "postde.yaml"
+    container "oras://jfallmann/monsda:postde"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("manifest.json") > 0)      "POSTDE/${SCOMBO}/${file(filename).getName()}"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/postde.log"
+    }
+
+    input:
+    path 'bundle'
+    path 'postde_inputs'
+
+    output:
+    path "postde/manifest.json", emit: manifest
+    path "log", emit: log
+
+    script:
+    """
+    cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "../bundle" --config "config.json" --output "../postde" 2> log
+    """
+}
+
 
 workflow DE{ 
     take: collection
@@ -232,6 +263,10 @@ workflow DE{
     create_summary_snippet(run_deseq2.out.tbls.concat(run_deseq2.out.figs.concat(run_deseq2.out.session)).collect())
     collect_deseq(filter_significant.out.sigtbls.collect())
 
+    if (POSTDE_ENABLED) {
+        postde(run_deseq2.out.bundle, Channel.fromPath(POSTDE_INPUTS))
+    }
+
     emit:
     tbls = run_deseq2.out.tbls
     sigtbls = filter_significant.out.sigtbls
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 0b2c4042..0bdb289c 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -5,6 +5,9 @@ comparison = comparable_as_string(config,'DE')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
 usespike = True if "controlgenes=" in tool_params(samplecond(SAMPLES, config)[0], None, config, "DE", DEENV.split('_')[0])['OPTIONS'].get('DE', "") else False
+postde_enabled = config.get('POSTDE', {}).get('enabled', False)
+postde_inputs = config.get('POSTDE', {}).get('inputs', '') if postde_enabled else ''
+postde_flag = '1' if postde_enabled else '0'
 
 rule themall:
     input:  session = expand("DE/{combo}/DE_DESEQ2_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
@@ -20,7 +23,8 @@ rule themall:
             sig   = expand("DE/{combo}/Tables/Sig_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/Sig_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             sig_d = expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             sig_u = expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
-            Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+            Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
+            postde = expand("POSTDE/{combo}/manifest.json", combo=combo) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)
@@ -64,7 +68,8 @@ rule run_deseq2:
             vulcan = rules.themall.input.vulcan,
             vst    = rules.themall.input.vst,
             heat   = rules.themall.input.heat,
-            heats  = rules.themall.input.heats
+            heats  = rules.themall.input.heats,
+            bundle = expand("DE/{combo}/DE_deseq2_{scombo}_postde.rds", combo=combo, scombo=scombo) if postde_enabled else []
     log:    expand("LOGS/{combo}/DE/deseq2/run_deseq2.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
@@ -75,7 +80,7 @@ rule run_deseq2:
             pcombo = scombo if scombo != '' else 'none',
             ref = ANNOTATION,
             depara = lambda wildcards: tool_params(samplecond(SAMPLES, config)[0], None, config, "DE", DEENV.split('_')[0])['OPTIONS'].get('DE', "")
-    shell:  "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.cnt} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}"
+    shell:  "MONSDA_POSTDE={postde_flag} Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.cnt} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}"
 
 rule filter_significant:
     input:  tbl = rules.run_deseq2.output.tbl
@@ -113,3 +118,17 @@ rule create_summary_snippet:
     params: bins = BINS,
             abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
     shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEENV} --loglevel DEBUG 2>> {log}"
+
+if postde_enabled:
+    rule postde:
+        input:  bundle = rules.run_deseq2.output.bundle,
+                staged = postde_inputs
+        output: manifest = expand("POSTDE/{combo}/manifest.json", combo=combo)
+        log:    expand("LOGS/{combo}/DE/deseq2/postde.log", combo=combo)
+        conda:  "postde.yaml"
+        container: "oras://jfallmann/monsda:postde"
+        threads: 1
+        params: bins = BINS,
+                bundle = lambda w, input: os.path.abspath(input.bundle[0]),
+                outdir = lambda w: os.path.abspath(os.path.join('POSTDE', combo))
+        shell:  "cd {input.staged} && Rscript {params.bins}/Analysis/PostDE/run.R --bundle {params.bundle} --config config.json --output {params.outdir} 2> {log}"
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 52d6620e..1c41f721 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -12,6 +12,9 @@ DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
 PCOMBO = get_always('COMBO') ?: 'none'
+POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
+POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
+POSTDE_FLAG = POSTDE_ENABLED ? '1' : '0'
 
 COUNTBIN = 'featureCounts'
 COUNTENV = 'countreads_de'
@@ -111,6 +114,7 @@ process run_edger{
         if (filename.indexOf("_table") > 0)      "DE/${SCOMBO}/Tables/${file(filename).getName()}"                
         else if (filename.indexOf("_figure") > 0)      "DE/${SCOMBO}/Figures/${file(filename).getName()}"                
         else if (filename.indexOf("SESSION") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"                     
+        else if (filename.indexOf("_postde") > 0)      "DE/${SCOMBO}/${file(filename).getName()}"
         else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/run_edger.log"
     }
 
@@ -125,6 +129,7 @@ process run_edger{
     path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
+    path "*_postde.rds", emit: bundle, optional: true
     path "log", emit: log
 
     script:    
@@ -132,7 +137,7 @@ process run_edger{
     bin = "${BINS}"+File.separatorChar+"${DEBIN}"
     """
     mkdir -p Figures Tables
-    Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
+    MONSDA_POSTDE=${POSTDE_FLAG} Rscript --no-environ --no-restore --no-save $bin $anno $cts $deanno . $DECOMP $PCOMBO ${task.cpus} $DEPARAMS 2> log && mv Tables/* . && mv Figures/* .
     """
 }
 
@@ -206,6 +211,32 @@ process collect_edger{
     """
 }
 
+process postde{
+    conda "postde.yaml"
+    container "oras://jfallmann/monsda:postde"
+    cpus THREADS
+	cache 'lenient'
+
+    publishDir "${workflow.workDir}/../" , mode: 'link',
+    saveAs: {filename ->
+        if (filename.indexOf("manifest.json") > 0)      "POSTDE/${SCOMBO}/${file(filename).getName()}"
+        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/postde.log"
+    }
+
+    input:
+    path 'bundle'
+    path 'postde_inputs'
+
+    output:
+    path "postde/manifest.json", emit: manifest
+    path "log", emit: log
+
+    script:
+    """
+    cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "../bundle" --config "config.json" --output "../postde" 2> log
+    """
+}
+
 workflow DE{ 
     take: collection
 
@@ -233,6 +264,10 @@ workflow DE{
     create_summary_snippet(run_edger.out.tbls.concat(run_edger.out.figs.concat(run_edger.out.session)).collect())
     collect_edger(filter_significant.out.sigtbls.collect())
 
+    if (POSTDE_ENABLED) {
+        postde(run_edger.out.bundle, Channel.fromPath(POSTDE_INPUTS))
+    }
+
     emit:
     tbls = run_edger.out.tbls
     sigtbls = filter_significant.out.sigtbls
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index d7d6578f..8c01e318 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -5,6 +5,9 @@ comparison = comparable_as_string(config,'DE')
 compstr = [i.split(":")[0] for i in comparison.split(",")]
 usededup = config.get('RUNDEDUP', False)
 usespike = True if "controlgenes=" in tool_params(samplecond(SAMPLES, config)[0], None, config, "DE", DEENV.split('_')[0])['OPTIONS'].get('DE', "") else False
+postde_enabled = config.get('POSTDE', {}).get('enabled', False)
+postde_inputs = config.get('POSTDE', {}).get('inputs', '') if postde_enabled else ''
+postde_flag = '1' if postde_enabled else '0'
 
 rule themall:
     input:  session = expand("DE/{combo}/DE_EDGER_{scombo}_SESSION.gz", combo=combo, scombo=scombo),
@@ -19,7 +22,8 @@ rule themall:
             sig     = expand("DE/{combo}/Tables/Sig_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/Sig_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             sig_u   = expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             sig_d   = expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
-            Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo)
+            Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
+            postde = expand("POSTDE/{combo}/manifest.json", combo=combo) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)
@@ -62,7 +66,8 @@ rule run_edger:
             vulcan  = rules.themall.input.vulcan,
             allN    = rules.themall.input.allN,
             res     = rules.themall.input.res,
-            sort    = rules.themall.input.sort
+            sort    = rules.themall.input.sort,
+            bundle = expand("DE/{combo}/DE_edger_{scombo}_postde.rds", combo=combo, scombo=scombo) if postde_enabled else []
     log:    expand("LOGS/{combo}/DE/edger/run_edger.log", combo=combo)
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
@@ -73,7 +78,7 @@ rule run_edger:
             pcombo = scombo if scombo != '' else 'none',
             ref = ANNOTATION,
             depara = lambda wildcards: tool_params(samplecond(SAMPLES, config)[0], None, config, "DE", DEENV.split('_')[0])['OPTIONS'].get('DE', "")
-    shell: "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.tbl} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}"
+    shell: "MONSDA_POSTDE={postde_flag} Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {input.tbl} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.depara}\' 2> {log}"
 
 rule filter_significant:
     input:  tbl = rules.run_edger.output.sort
@@ -110,3 +115,17 @@ rule create_summary_snippet:
     params: bins = BINS,
             abspathfiles = lambda w, input: [os.path.abspath(x) for x in input]
     shell:  "python3 {params.bins}/Analysis/RmdCreator.py --files {params.abspathfiles} --output {output} --env {DEENV} --loglevel DEBUG 2>> {log}"
+
+if postde_enabled:
+    rule postde:
+        input:  bundle = rules.run_edger.output.bundle,
+                staged = postde_inputs
+        output: manifest = expand("POSTDE/{combo}/manifest.json", combo=combo)
+        log:    expand("LOGS/{combo}/DE/edger/postde.log", combo=combo)
+        conda:  "postde.yaml"
+        container: "oras://jfallmann/monsda:postde"
+        threads: 1
+        params: bins = BINS,
+                bundle = lambda w, input: os.path.abspath(input.bundle[0]),
+                outdir = lambda w: os.path.abspath(os.path.join('POSTDE', combo))
+        shell:  "cd {input.staged} && Rscript {params.bins}/Analysis/PostDE/run.R --bundle {params.bundle} --config config.json --output {params.outdir} 2> {log}"

From e7e938b8d79808bdb9789bff0cbb7f3020b6925f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 13:00:45 +0200
Subject: [PATCH 63/80] still postde WIP

---
 MONSDA/PostDE.py        | 84 +++++++++++++++++++++++++----------------
 MONSDA/RunMONSDA.py     |  2 +-
 workflows/deseq2_DE.nf  | 16 +++++---
 workflows/deseq2_DE.smk | 20 ++++++----
 workflows/edger_DE.nf   | 16 +++++---
 workflows/edger_DE.smk  | 20 ++++++----
 6 files changed, 97 insertions(+), 61 deletions(-)

diff --git a/MONSDA/PostDE.py b/MONSDA/PostDE.py
index 20c683c4..a0e170c0 100644
--- a/MONSDA/PostDE.py
+++ b/MONSDA/PostDE.py
@@ -1,5 +1,7 @@
+import filecmp
 import hashlib
 import json
+import math
 import os
 import shutil
 
@@ -64,6 +66,11 @@
     "decoupler": ("network",),
     "dream": ("metadata",),
 }
+POSTDE_BOOL_FLAGS = {
+    "gprofiler": ("allow_network",),
+    "clusterprofiler": ("go_expand",),
+    "decoupler": ("allow_network", "contrast_activity"),
+}
 POSTDE_SUPPORTED_DE_TOOLS = frozenset({"deseq2", "edger"})
 POSTDE_DOMAIN_SCOPES = ("annotated", "known", "custom", "custom_annotated")
 POSTDE_CORRECTION_METHODS = (
@@ -80,7 +87,15 @@
 
 
 def _is_number(value):
-    return isinstance(value, (int, float)) and not isinstance(value, bool)
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(value)
+    )
+
+
+def _is_integral(value):
+    return _is_number(value) and value == int(value)
 
 
 def _validate_analysis_config(analysis, base_dir):
@@ -98,17 +113,17 @@ def _validate_analysis_config(analysis, base_dir):
         not _is_number(analysis["lfc"]) or analysis["lfc"] < 0
     ):
         raise ValueError("POSTDE config lfc must be numeric >= 0")
-    if "seed" in analysis and not _is_number(analysis["seed"]):
-        raise ValueError("POSTDE config seed must be numeric")
+    if "seed" in analysis and not _is_integral(analysis["seed"]):
+        raise ValueError("POSTDE config seed must be a finite integer")
     if "min_size" in analysis and (
-        not _is_number(analysis["min_size"]) or analysis["min_size"] < 1
+        not _is_integral(analysis["min_size"]) or analysis["min_size"] < 1
     ):
-        raise ValueError("POSTDE config min_size must be numeric >= 1")
+        raise ValueError("POSTDE config min_size must be an integer >= 1")
     if "max_size" in analysis and (
-        not _is_number(analysis["max_size"])
+        not _is_integral(analysis["max_size"])
         or analysis["max_size"] < analysis.get("min_size", 1)
     ):
-        raise ValueError("POSTDE config max_size must be numeric >= min_size")
+        raise ValueError("POSTDE config max_size must be an integer >= min_size")
     for method, keys in POSTDE_METHOD_KEYS.items():
         sub = analysis.get(method)
         if sub is None:
@@ -127,6 +142,11 @@ def _validate_analysis_config(analysis, base_dir):
             raise ValueError(
                 "POSTDE config " + method + ".enabled must be a boolean"
             )
+        for flag in POSTDE_BOOL_FLAGS.get(method, ()):
+            if flag in sub and not isinstance(sub[flag], bool):
+                raise ValueError(
+                    "POSTDE config " + method + "." + flag + " must be a boolean"
+                )
     for vis in ("plots", "report", "shiny"):
         if analysis.get(vis, {}).get("enabled"):
             raise ValueError(
@@ -167,14 +187,14 @@ def _validate_analysis_config(analysis, base_dir):
             "POSTDE config gsva.method must be one of " + ", ".join(POSTDE_GSVA_METHODS)
         )
     if "min_size" in gs and (
-        not _is_number(gs["min_size"]) or gs["min_size"] < 1
+        not _is_integral(gs["min_size"]) or gs["min_size"] < 1
     ):
-        raise ValueError("POSTDE config gsva.min_size must be numeric >= 1")
+        raise ValueError("POSTDE config gsva.min_size must be an integer >= 1")
     if "max_size" in gs and (
-        not _is_number(gs["max_size"])
+        not _is_integral(gs["max_size"])
         or gs["max_size"] < gs.get("min_size", analysis.get("min_size", 1))
     ):
-        raise ValueError("POSTDE config gsva.max_size must be numeric >= min_size")
+        raise ValueError("POSTDE config gsva.max_size must be an integer >= min_size")
     dc = analysis.get("decoupler", {})
     if dc.get("enabled"):
         if not dc.get("network") and not dc.get("allow_network"):
@@ -198,11 +218,11 @@ def _validate_analysis_config(analysis, base_dir):
                     + ", ".join(POSTDE_DECOUPLER_METHODS)
                 )
         if "min_size" in dc and (
-            not _is_number(dc["min_size"]) or dc["min_size"] < 1
+            not _is_integral(dc["min_size"]) or dc["min_size"] < 1
         ):
-            raise ValueError("POSTDE config decoupler.min_size must be numeric >= 1")
-        if "top" in dc and (not _is_number(dc["top"]) or dc["top"] < 1):
-            raise ValueError("POSTDE config decoupler.top must be numeric >= 1")
+            raise ValueError("POSTDE config decoupler.min_size must be an integer >= 1")
+        if "top" in dc and (not _is_integral(dc["top"]) or dc["top"] < 1):
+            raise ValueError("POSTDE config decoupler.top must be an integer >= 1")
     dm = analysis.get("dream", {})
     if dm.get("enabled"):
         if not isinstance(dm.get("metadata"), str) or not dm["metadata"].strip():
@@ -294,18 +314,9 @@ def _collect_resources(analysis, base_dir):
     return resources
 
 
-def _staged_names(resources):
-    by_basename = {}
-    for method, key, full in resources:
-        by_basename.setdefault(os.path.basename(full), []).append((method, key, full))
-    names = {}
-    for bn, items in by_basename.items():
-        if len(items) == 1:
-            names[(items[0][0], items[0][1])] = bn
-        else:
-            for method, key, full in items:
-                names[(method, key)] = key + "_" + bn
-    return names
+def _staged_name(method, key, full):
+    ext = os.path.splitext(os.path.basename(full))[1]
+    return method + "_" + key + ext
 
 
 def prepare_postde(config, subdir):
@@ -322,14 +333,23 @@ def prepare_postde(config, subdir):
     for method, key, full in sorted(resources):
         with open(full, "rb") as fh:
             digest.update(fh.read())
-    staged = os.path.join(subdir, "POSTDE_" + digest.hexdigest()[:12])
-    if os.path.isdir(staged) and os.path.isfile(os.path.join(staged, "config.json")):
-        return staged
+    staged = os.path.join(os.path.abspath(subdir), "POSTDE_" + digest.hexdigest()[:12])
+    names = {
+        (method, key): _staged_name(method, key, full)
+        for method, key, full in resources
+    }
+    if os.path.isdir(staged):
+        expected = [os.path.join(staged, names[(m, k)]) for m, k, _ in resources]
+        expected.append(os.path.join(staged, "config.json"))
+        if all(os.path.isfile(p) for p in expected) and all(
+            filecmp.cmp(full, os.path.join(staged, names[(m, k)]), shallow=False)
+            for m, k, full in resources
+        ):
+            return staged
     os.makedirs(staged, exist_ok=True)
-    names = _staged_names(resources)
     for method, key, full in resources:
         dst = os.path.join(staged, names[(method, key)])
-        if not os.path.exists(dst) or not shutil.cmp(full, dst):
+        if not os.path.exists(dst) or not filecmp.cmp(full, dst, shallow=False):
             shutil.copy2(full, dst)
     staged_analysis = json.loads(json.dumps(analysis))
     for method, key, full in resources:
diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index 655cbb78..b75c096f 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -1033,7 +1033,7 @@ def main():
             log.info("Running MONSDA version " + __version__ + " as configured")
 
         postde_section = config.get("POSTDE")
-        if postde_section and postde_section.get("enabled"):
+        if postde_section is not None:
             try:
                 mw.load_postde_config(postde_section, config=config)
             except ValueError as err:
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index c53128fd..315f1421 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -11,6 +11,7 @@ DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
 PCOMBO = get_always('COMBO') ?: 'none'
+PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
 POSTDE_FLAG = POSTDE_ENABLED ? '1' : '0'
@@ -129,7 +130,7 @@ process run_deseq2{
     path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
-    path "*_postde.rds", emit: bundle, optional: true
+    path "DE_deseq2_${PCOMBO_NORM}_postde.rds", emit: bundle, optional: !POSTDE_ENABLED
     path "log", emit: log
 
     script:    
@@ -218,8 +219,8 @@ process postde{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("manifest.json") > 0)      "POSTDE/${SCOMBO}/${file(filename).getName()}"
-        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/deseq2/postde.log"
+        if (filename == "log")      "LOGS/${SCOMBO}/DE/deseq2/postde.log"
+        else if (filename == "postde")      "POSTDE/${SCOMBO}"
     }
 
     input:
@@ -227,12 +228,15 @@ process postde{
     path 'postde_inputs'
 
     output:
-    path "postde/manifest.json", emit: manifest
+    path "postde", emit: postde_out
     path "log", emit: log
 
     script:
+    bundle = "${task.workDir}/bundle"
+    outdir = "${task.workDir}/postde"
+    logfile = "${task.workDir}/log"
     """
-    cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "../bundle" --config "config.json" --output "../postde" 2> log
+    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "$bundle" --config "config.json" --output "$outdir") 2> "$logfile" && test -s "$outdir/manifest.json"
     """
 }
 
@@ -264,7 +268,7 @@ workflow DE{
     collect_deseq(filter_significant.out.sigtbls.collect())
 
     if (POSTDE_ENABLED) {
-        postde(run_deseq2.out.bundle, Channel.fromPath(POSTDE_INPUTS))
+        postde(run_deseq2.out.bundle, Channel.fromPath(POSTDE_INPUTS, checkIfExists: true, type: 'dir'))
     }
 
     emit:
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 0bdb289c..cbcbb0ba 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -24,7 +24,7 @@ rule themall:
             sig_d = expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             sig_u = expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
-            postde = expand("POSTDE/{combo}/manifest.json", combo=combo) if postde_enabled else []
+            postde = directory(expand("POSTDE/{combo}", combo=combo)) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)
@@ -122,13 +122,17 @@ rule create_summary_snippet:
 if postde_enabled:
     rule postde:
         input:  bundle = rules.run_deseq2.output.bundle,
-                staged = postde_inputs
-        output: manifest = expand("POSTDE/{combo}/manifest.json", combo=combo)
-        log:    expand("LOGS/{combo}/DE/deseq2/postde.log", combo=combo)
+                staged = postde_inputs,
+                config = os.path.join(postde_inputs, "config.json"),
+                script = os.path.join(BINS, "Analysis", "PostDE", "run.R"),
+                common = os.path.join(BINS, "Analysis", "PostDE", "common.R"),
+                enrichment = os.path.join(BINS, "Analysis", "PostDE", "enrichment.R"),
+                regulatory = os.path.join(BINS, "Analysis", "PostDE", "regulatory.R")
+        output: outdir = directory(expand("POSTDE/{combo}", combo=combo))
+        log:    os.path.abspath(os.path.join("LOGS", combo, "DE", "deseq2", "postde.log"))
         conda:  "postde.yaml"
         container: "oras://jfallmann/monsda:postde"
         threads: 1
-        params: bins = BINS,
-                bundle = lambda w, input: os.path.abspath(input.bundle[0]),
-                outdir = lambda w: os.path.abspath(os.path.join('POSTDE', combo))
-        shell:  "cd {input.staged} && Rscript {params.bins}/Analysis/PostDE/run.R --bundle {params.bundle} --config config.json --output {params.outdir} 2> {log}"
+        params: bundle = lambda w, input: os.path.abspath(input.bundle[0]),
+                outdir = lambda w: os.path.abspath(os.path.join("POSTDE", combo))
+        shell:  "(cd {input.staged:q} && Rscript {input.script:q} --bundle {params.bundle:q} --config config.json --output {params.outdir:q}) 2> {log:q} && test -s {params.outdir:q}/manifest.json"
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 1c41f721..753bd5fe 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -12,6 +12,7 @@ DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
 PCOMBO = get_always('COMBO') ?: 'none'
+PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
 POSTDE_FLAG = POSTDE_ENABLED ? '1' : '0'
@@ -129,7 +130,7 @@ process run_edger{
     path "*_table_results*.tsv.gz", emit: result_tbls
     path "*_figure*", emit: figs
     path "*SESSION.gz", emit: session
-    path "*_postde.rds", emit: bundle, optional: true
+    path "DE_edger_${PCOMBO_NORM}_postde.rds", emit: bundle, optional: !POSTDE_ENABLED
     path "log", emit: log
 
     script:    
@@ -219,8 +220,8 @@ process postde{
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
-        if (filename.indexOf("manifest.json") > 0)      "POSTDE/${SCOMBO}/${file(filename).getName()}"
-        else if (filename.indexOf("log") > 0)        "LOGS/${SCOMBO}/DE/edger/postde.log"
+        if (filename == "log")      "LOGS/${SCOMBO}/DE/edger/postde.log"
+        else if (filename == "postde")      "POSTDE/${SCOMBO}"
     }
 
     input:
@@ -228,12 +229,15 @@ process postde{
     path 'postde_inputs'
 
     output:
-    path "postde/manifest.json", emit: manifest
+    path "postde", emit: postde_out
     path "log", emit: log
 
     script:
+    bundle = "${task.workDir}/bundle"
+    outdir = "${task.workDir}/postde"
+    logfile = "${task.workDir}/log"
     """
-    cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "../bundle" --config "config.json" --output "../postde" 2> log
+    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "$bundle" --config "config.json" --output "$outdir") 2> "$logfile" && test -s "$outdir/manifest.json"
     """
 }
 
@@ -265,7 +269,7 @@ workflow DE{
     collect_edger(filter_significant.out.sigtbls.collect())
 
     if (POSTDE_ENABLED) {
-        postde(run_edger.out.bundle, Channel.fromPath(POSTDE_INPUTS))
+        postde(run_edger.out.bundle, Channel.fromPath(POSTDE_INPUTS, checkIfExists: true, type: 'dir'))
     }
 
     emit:
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index 8c01e318..b1eb0bd4 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -23,7 +23,7 @@ rule themall:
             sig_u   = expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             sig_d   = expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
-            postde = expand("POSTDE/{combo}/manifest.json", combo=combo) if postde_enabled else []
+            postde = directory(expand("POSTDE/{combo}", combo=combo)) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)
@@ -119,13 +119,17 @@ rule create_summary_snippet:
 if postde_enabled:
     rule postde:
         input:  bundle = rules.run_edger.output.bundle,
-                staged = postde_inputs
-        output: manifest = expand("POSTDE/{combo}/manifest.json", combo=combo)
-        log:    expand("LOGS/{combo}/DE/edger/postde.log", combo=combo)
+                staged = postde_inputs,
+                config = os.path.join(postde_inputs, "config.json"),
+                script = os.path.join(BINS, "Analysis", "PostDE", "run.R"),
+                common = os.path.join(BINS, "Analysis", "PostDE", "common.R"),
+                enrichment = os.path.join(BINS, "Analysis", "PostDE", "enrichment.R"),
+                regulatory = os.path.join(BINS, "Analysis", "PostDE", "regulatory.R")
+        output: outdir = directory(expand("POSTDE/{combo}", combo=combo))
+        log:    os.path.abspath(os.path.join("LOGS", combo, "DE", "edger", "postde.log"))
         conda:  "postde.yaml"
         container: "oras://jfallmann/monsda:postde"
         threads: 1
-        params: bins = BINS,
-                bundle = lambda w, input: os.path.abspath(input.bundle[0]),
-                outdir = lambda w: os.path.abspath(os.path.join('POSTDE', combo))
-        shell:  "cd {input.staged} && Rscript {params.bins}/Analysis/PostDE/run.R --bundle {params.bundle} --config config.json --output {params.outdir} 2> {log}"
+        params: bundle = lambda w, input: os.path.abspath(input.bundle[0]),
+                outdir = lambda w: os.path.abspath(os.path.join("POSTDE", combo))
+        shell:  "(cd {input.staged:q} && Rscript {input.script:q} --bundle {params.bundle:q} --config config.json --output {params.outdir:q}) 2> {log:q} && test -s {params.outdir:q}/manifest.json"

From 1cad1f7d2d092e2542a15b6c1778baa33fc8710e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 13:28:20 +0200
Subject: [PATCH 64/80] still wip

---
 MONSDA/PostDE.py               |  45 ++--
 scripts/Analysis/PostDE/run.R  |   0
 tests/test_postde_workflows.py | 378 ++++++++++++++++++++++++++++++---
 workflows/deseq2_DE.nf         |   8 +-
 workflows/edger_DE.nf          |   8 +-
 5 files changed, 388 insertions(+), 51 deletions(-)
 mode change 100644 => 100755 scripts/Analysis/PostDE/run.R

diff --git a/MONSDA/PostDE.py b/MONSDA/PostDE.py
index a0e170c0..64931055 100644
--- a/MONSDA/PostDE.py
+++ b/MONSDA/PostDE.py
@@ -1,4 +1,3 @@
-import filecmp
 import hashlib
 import json
 import math
@@ -319,6 +318,19 @@ def _staged_name(method, key, full):
     return method + "_" + key + ext
 
 
+def _same_content(path_a, path_b):
+    """Compare file contents directly (readbytes), immune to stat-based
+    caching that can miss same-size/same-mtime content mutations."""
+    with open(path_a, "rb") as fh_a, open(path_b, "rb") as fh_b:
+        return fh_a.read() == fh_b.read()
+
+
+def _same_text(path, text):
+    """Compare a file's bytes against an expected text string."""
+    with open(path, "rb") as fh:
+        return fh.read() == text.encode("utf-8")
+
+
 def prepare_postde(config, subdir):
     section = load_postde_config(config.get("POSTDE"), config=config)
     if section is None or not section.get("enabled"):
@@ -338,22 +350,31 @@ def prepare_postde(config, subdir):
         (method, key): _staged_name(method, key, full)
         for method, key, full in resources
     }
+    staged_analysis = json.loads(json.dumps(analysis))
+    for method, key, full in resources:
+        staged_analysis[method][key] = names[(method, key)]
+    expected_config = json.dumps(staged_analysis, indent=2)
     if os.path.isdir(staged):
-        expected = [os.path.join(staged, names[(m, k)]) for m, k, _ in resources]
-        expected.append(os.path.join(staged, "config.json"))
-        if all(os.path.isfile(p) for p in expected) and all(
-            filecmp.cmp(full, os.path.join(staged, names[(m, k)]), shallow=False)
+        staged_config = os.path.join(staged, "config.json")
+        config_ok = os.path.isfile(staged_config) and _same_text(
+            staged_config, expected_config
+        )
+        resources_ok = all(
+            os.path.isfile(os.path.join(staged, names[(m, k)]))
+            and _same_content(full, os.path.join(staged, names[(m, k)]))
             for m, k, full in resources
-        ):
+        )
+        if config_ok and resources_ok:
             return staged
     os.makedirs(staged, exist_ok=True)
     for method, key, full in resources:
         dst = os.path.join(staged, names[(method, key)])
-        if not os.path.exists(dst) or not filecmp.cmp(full, dst, shallow=False):
+        if not os.path.exists(dst) or not _same_content(full, dst):
             shutil.copy2(full, dst)
-    staged_analysis = json.loads(json.dumps(analysis))
-    for method, key, full in resources:
-        staged_analysis[method][key] = names[(method, key)]
-    with open(os.path.join(staged, "config.json"), "w") as fh:
-        json.dump(staged_analysis, fh, indent=2)
+    staged_config = os.path.join(staged, "config.json")
+    if not os.path.isfile(staged_config) or not _same_text(
+        staged_config, expected_config
+    ):
+        with open(staged_config, "w") as fh:
+            fh.write(expected_config)
     return staged
diff --git a/scripts/Analysis/PostDE/run.R b/scripts/Analysis/PostDE/run.R
old mode 100644
new mode 100755
diff --git a/tests/test_postde_workflows.py b/tests/test_postde_workflows.py
index 8a7c84ff..819829a3 100644
--- a/tests/test_postde_workflows.py
+++ b/tests/test_postde_workflows.py
@@ -1,9 +1,12 @@
 import json
 import os
 import re
+import shlex
 import shutil
+import string
 import subprocess
 import sys
+import types
 from pathlib import Path
 
 import pytest
@@ -33,6 +36,12 @@ def _repo_template_paths(monkeypatch):
     mw.workflowpath, mw.envpath, mw.binpath = old_wf, old_env, old_bin
 
 
+@pytest.fixture(autouse=True)
+def _sandbox_chdir(tmp_path, monkeypatch):
+    """All staging tests run inside tmp_path so the repo tree is never touched."""
+    monkeypatch.chdir(tmp_path)
+
+
 def _load(name):
     return load_configfile(str(DATA / name))
 
@@ -40,13 +49,12 @@ def _load(name):
 @pytest.fixture
 def workdir(tmp_path):
     for item in os.listdir(DATA):
-        os.symlink(DATA / item, tmp_path / item)
-    old = os.getcwd()
-    os.chdir(tmp_path)
-    try:
-        yield tmp_path
-    finally:
-        os.chdir(old)
+        src = DATA / item
+        if src.is_dir():
+            os.symlink(src, tmp_path / item)
+        else:
+            shutil.copy2(src, tmp_path / item)
+    return tmp_path
 
 
 def _analysis_config(tmp_path, analysis, name="postde_analysis.json"):
@@ -112,6 +120,84 @@ def _write_stub_bundle(rscript, path):
     )
 
 
+def _write_real_bundle(rscript, outdir, engine):
+    """Create a tiny valid postde bundle via export.R: 50 genes x 4 samples
+    (2 conditions, 2 reps), one contrast A-VS-B. Returns the bundle path."""
+    export_r = REPO / "scripts" / "Analysis" / "PostDE" / "export.R"
+    rcode = (
+        "args <- commandArgs(trailingOnly = TRUE)\n"
+        "export_r <- args[1]\n"
+        "outdir <- args[2]\n"
+        "engine <- args[3]\n"
+        "postde_lib <- export_r\n"
+        "source(export_r)\n"
+        "set.seed(42)\n"
+        "genes <- paste0('G', seq_len(50))\n"
+        "samples <- c('S1', 'S2', 'S3', 'S4')\n"
+        "condition <- factor(c('A', 'A', 'B', 'B'), levels = c('A', 'B'))\n"
+        "metadata <- data.frame(row.names = samples, condition = condition)\n"
+        "counts <- matrix(rnbinom(50 * 4, mu = 100, size = 10), nrow = 50, "
+        "dimnames = list(genes, samples))\n"
+        "expression <- matrix(rnorm(50 * 4), nrow = 50, "
+        "dimnames = list(genes, samples))\n"
+        "results <- data.frame(gene_id = genes, logFC = rnorm(50), "
+        "pvalue = runif(50), padj = runif(50), stat = rnorm(50), "
+        "mean = runif(50, 1, 100), row.names = genes, "
+        "stringsAsFactors = FALSE)\n"
+        "formula <- ~condition\n"
+        "postde_capture(engine = engine, id = 'A-VS-B', A = 'A', B = 'B', "
+        "normalized = FALSE, metadata = metadata, counts = counts, "
+        "expression = expression, formula = formula, results = results, "
+        "mean_scale = 'baseMean')\n"
+        "postde_write(outdir, combi = '', engine = engine)\n"
+    )
+    rfile = outdir / ("make_bundle_" + engine + ".R")
+    rfile.write_text(rcode)
+    subprocess.run(
+        [rscript, str(rfile), str(export_r), str(outdir), engine],
+        check=True,
+        capture_output=True,
+    )
+    return outdir / ("DE_" + engine + "__postde.rds")
+
+
+def _extract_smk_rule_body(smk, rule_name):
+    match = re.search(r"^\s*rule\s+" + rule_name + r"\s*:\s*$", smk, re.M)
+    assert match, f"rule {rule_name} not found in generated snakefile"
+    rest = smk[match.end():]
+    body = []
+    for ln in rest.split("\n"):
+        if body and re.match(
+            r"^\s*(rule|if|include|configfile|import|from|onsuccess|onerror)\b", ln
+        ):
+            break
+        body.append(ln)
+    return "\n".join(body)
+
+
+def _smk_params_shell(body):
+    params_m = re.search(r"params:\s*(.*?)(?=\n\s*shell:)", body, re.S)
+    assert params_m, "params block not found in rule body"
+    shell_m = re.search(r'shell:\s*"(.*?)"', body, re.S)
+    assert shell_m, "shell block not found in rule body"
+    lines = params_m.group(1).split("\n")
+    code = "\n".join(
+        [lines[0].strip().rstrip(",")]
+        + [ln.strip().rstrip(",") for ln in lines[1:] if ln.strip()]
+    )
+    return code, shell_m.group(1)
+
+
+def _format_shell(template, **fields):
+    class _QFmt(string.Formatter):
+        def format_field(self, value, spec):
+            if spec == "q":
+                return shlex.quote(str(value))
+            return super().format_field(value, spec)
+
+    return _QFmt().format(template, **fields)
+
+
 class TestLoadPostdeConfig:
     def test_none_returns_none(self):
         assert load_postde_config(None) is None
@@ -231,13 +317,19 @@ def test_stages_config_and_resources(self, tmp_path):
         cfg = _postde_cfg(tmp_path, analysis)
         staged = prepare_postde(cfg, "SubSnakes")
         assert staged is not None
-        assert staged.startswith("SubSnakes" + os.sep + "POSTDE_")
+        assert staged.startswith(os.path.abspath("SubSnakes") + os.sep + "POSTDE_")
         assert os.path.isfile(os.path.join(staged, "config.json"))
-        assert os.path.isfile(os.path.join(staged, "term2gene.tsv"))
-        assert os.path.isfile(os.path.join(staged, "term2name.tsv"))
+        assert os.path.isfile(os.path.join(staged, "clusterprofiler_term2gene.tsv"))
+        assert os.path.isfile(os.path.join(staged, "clusterprofiler_term2name.tsv"))
         staged_cfg = json.load(open(os.path.join(staged, "config.json")))
-        assert staged_cfg["clusterprofiler"]["term2gene"] == "term2gene.tsv"
-        assert staged_cfg["clusterprofiler"]["term2name"] == "term2name.tsv"
+        assert (
+            staged_cfg["clusterprofiler"]["term2gene"]
+            == "clusterprofiler_term2gene.tsv"
+        )
+        assert (
+            staged_cfg["clusterprofiler"]["term2name"]
+            == "clusterprofiler_term2name.tsv"
+        )
 
     def test_relative_resource_paths(self, tmp_path):
         resdir = tmp_path / "res"
@@ -253,7 +345,7 @@ def test_relative_resource_paths(self, tmp_path):
         }
         cfg = _postde_cfg(tmp_path, analysis)
         staged = prepare_postde(cfg, "SubSnakes")
-        assert os.path.isfile(os.path.join(staged, "background.tsv"))
+        assert os.path.isfile(os.path.join(staged, "gprofiler_background.tsv"))
 
     def test_duplicate_basenames(self, tmp_path):
         (tmp_path / "background.tsv").write_text("G1\n")
@@ -275,8 +367,9 @@ def test_duplicate_basenames(self, tmp_path):
         cfg = _postde_cfg(tmp_path, analysis)
         staged = prepare_postde(cfg, "SubSnakes")
         names = sorted(os.listdir(staged))
-        assert "background.tsv" in names
-        assert "term2gene_background.tsv" in names
+        assert "gprofiler_background.tsv" in names
+        assert "clusterprofiler_term2gene.tsv" in names
+        assert "background.tsv" not in names
 
     def test_content_change_new_dir(self, tmp_path):
         (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
@@ -301,6 +394,28 @@ def test_reuse_existing_dir(self, tmp_path):
         assert staged1 == staged2
         assert os.path.getmtime(os.path.join(staged2, "config.json")) == mtime1
 
+    def test_cache_config_mutation_repaired(self, tmp_path):
+        (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
+        analysis = {
+            "padj": 0.05,
+            "clusterprofiler": {"enabled": True, "term2gene": "term2gene.tsv"},
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        staged1 = prepare_postde(cfg, "SubSnakes")
+        cfg_path = os.path.join(staged1, "config.json")
+        original = open(cfg_path).read()
+        # same-length in-place mutation of the staged config content
+        mutated = original.replace('"padj": 0.05', '"padj": 0.06')
+        assert len(mutated) == len(original)
+        with open(cfg_path, "w") as fh:
+            fh.write(mutated)
+        # preserve mtime to defeat stat-based caching
+        st = os.stat(cfg_path)
+        os.utime(cfg_path, (st.st_atime, st.st_mtime))
+        staged2 = prepare_postde(cfg, "SubSnakes")
+        assert staged1 == staged2
+        assert open(cfg_path).read() == original
+
 
 class TestWorkflowIntegration:
     def test_make_post_smk(self, workdir, tmp_path):
@@ -314,12 +429,15 @@ def test_make_post_smk(self, workdir, tmp_path):
             open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
         )
         assert confo["POSTDE"]["enabled"] is True
-        assert confo["POSTDE"]["inputs"].startswith("SubSnakes" + os.sep + "POSTDE_")
+        assert confo["POSTDE"]["inputs"].startswith(
+            os.path.abspath("SubSnakes") + os.sep + "POSTDE_"
+        )
         smk = (workdir / subdir / "allconditions_DE_deseq2_subsnake.smk").read_text()
         assert "rule postde" in smk
         assert "MONSDA_POSTDE={postde_flag}" in smk
         assert "DE_deseq2_{scombo}_postde.rds" in smk
-        assert "POSTDE/{combo}/manifest.json" in smk
+        assert "POSTDE/{combo}" in smk
+        assert "manifest.json" in smk
         smk_e = (workdir / subdir / "allconditions_DE_edger_subsnake.smk").read_text()
         assert "rule postde" in smk_e
         assert "DE_edger_{scombo}_postde.rds" in smk_e
@@ -335,11 +453,13 @@ def test_make_post_nf(self, workdir, tmp_path):
             open(workdir / subdir / "allconditions_DE_deseq2_subconfig.json")
         )
         assert confo["POSTDE"]["enabled"] is True
-        assert confo["POSTDE"]["inputs"].startswith("SubFlows" + os.sep + "POSTDE_")
+        assert confo["POSTDE"]["inputs"].startswith(
+            os.path.abspath("SubFlows") + os.sep + "POSTDE_"
+        )
         nf = (workdir / subdir / "allconditions_DE_deseq2_subflow.nf").read_text()
         assert "process postde" in nf
         assert "MONSDA_POSTDE=${params.gPOSTDE_FLAG}" in nf
-        assert "emit: bundle, optional: true" in nf
+        assert "emit: bundle, optional: !params.gPOSTDE_ENABLED" in nf
         assert "postde(run_deseq2.out.bundle" in nf
         nf_e = (workdir / subdir / "allconditions_DE_edger_subflow.nf").read_text()
         assert "process postde" in nf_e
@@ -354,8 +474,29 @@ def test_disabled_no_postde(self, workdir, tmp_path):
         )
         assert "POSTDE" not in confo
         smk = (workdir / subdir / "allconditions_DE_deseq2_subsnake.smk").read_text()
-        assert "rule postde" not in smk
-        assert "MONSDA_POSTDE=0" in smk
+        assert "MONSDA_POSTDE={postde_flag}" in smk
+        base = [
+            sys.executable,
+            "-m",
+            "snakemake",
+            "-s",
+            str(workdir / subdir / "allconditions_DE_deseq2_subsnake.smk"),
+            "--configfile",
+            str(workdir / subdir / "allconditions_DE_deseq2_subconfig.json"),
+            "--directory",
+            str(workdir),
+        ]
+        env = {**os.environ, "PYTHONPATH": str(REPO)}
+        listed = subprocess.run(
+            base + ["--list-rules"], capture_output=True, text=True, env=env
+        )
+        assert listed.returncode == 0, listed.stderr[-2000:]
+        assert "postde" not in listed.stdout
+        dag = subprocess.run(
+            base + ["-n", "POSTDE/deseq2_DE"], capture_output=True, text=True, env=env
+        )
+        assert dag.returncode != 0
+        assert "MissingRuleException" in dag.stderr or "No rule to produce" in dag.stderr
 
     def test_snakemake_dag_dryrun(self, workdir, tmp_path):
         (tmp_path / "term2gene.tsv").write_text("term\tgene\nGO:1\tG1\n")
@@ -382,7 +523,7 @@ def test_snakemake_dag_dryrun(self, workdir, tmp_path):
                 str(workdir / subdir / "allconditions_DE_deseq2_subconfig.json"),
                 "--directory",
                 str(workdir),
-                "POSTDE/deseq2_DE/manifest.json",
+                "POSTDE/deseq2_DE",
             ],
             capture_output=True,
             text=True,
@@ -406,19 +547,198 @@ def test_postde_process_body_runs(self, workdir, tmp_path):
         staged = confo["POSTDE"]["inputs"]
         subflow = (workdir / subdir / "allconditions_DE_deseq2_subflow.nf").read_text()
         script = _extract_nf_script(subflow, "postde")
-        bundle = workdir / "DE" / "deseq2_DE" / "DE_deseq2__postde.rds"
-        bundle.parent.mkdir(parents=True, exist_ok=True)
-        _write_stub_bundle(rscript, bundle)
-        outdir = workdir / "postde_out"
+        # simulate nextflow rendering of the escaped shell variables
+        script = script.replace("\\$", "$")
         script = script.replace("${params.gBINS}", str(REPO / "scripts"))
-        script = script.replace("postde_inputs", str(workdir / staged))
-        script = script.replace("../bundle", str(bundle))
-        script = script.replace("../postde", str(outdir))
+        _write_stub_bundle(rscript, workdir / "bundle")
+        os.symlink(workdir / staged, workdir / "postde_inputs")
         result = subprocess.run(
             script, shell=True, cwd=str(workdir), capture_output=True, text=True
         )
         assert result.returncode == 0, result.stderr[-2000:]
+        assert (workdir / "postde" / "manifest.json").exists()
+        assert (workdir / "log").exists()
+
+
+class TestPostdeDefaults:
+    def test_gsva_and_global_minmax_defaults(self, tmp_path):
+        """Effective GSVA/global min/max defaults must match the R
+        common/enrichment defaults (10/500), not arbitrary values."""
+        rscript = shutil.which("Rscript")
+        if not rscript:
+            pytest.skip("Rscript not found on PATH")
+        rcode = (
+            "run_src <- readLines('run.R')\n"
+            "run_src <- run_src[!grepl('^postde_main\\\\(\\\\)\\\\s*$', run_src)]\n"
+            "srcfile <- tempfile(fileext = '.R')\n"
+            "writeLines(run_src, srcfile)\n"
+            "source(srcfile)\n"
+            'source("common.R")\n'
+            "config <- postde_config_defaults(list())\n"
+            'cat("global", config$min_size, config$max_size, "\\n")\n'
+            "f <- formals(postde_gsva_scores)\n"
+            'cat("gsva", f$min_size, f$max_size, "\\n")\n'
+            'source("enrichment.R")\n'
+            "samples <- c('S1', 'S2', 'S3', 'S4')\n"
+            "cond <- factor(c('A', 'A', 'B', 'B'), levels = c('A', 'B'))\n"
+            "md <- data.frame(row.names = samples, condition = cond)\n"
+            "design <- model.matrix(~condition, data = md)\n"
+            "contrast <- c('(Intercept)' = 0, 'conditionB' = 1)\n"
+            "entry <- list(\n"
+            "    id = 'A-VS-B',\n"
+            "    expression = matrix(rnorm(200), nrow = 50,\n"
+            "        dimnames = list(paste0('G', 1:50), samples)),\n"
+            "    design = design,\n"
+            "    contrast = contrast\n"
+            ")\n"
+            "term2gene <- data.frame(term = c('T1', 'T1', 'T2', 'T2'),\n"
+            "    gene = c('G1', 'G2', 'G3', 'G4'))\n"
+            "config <- list(min_size = 10, max_size = 500,\n"
+            "    gsva = list(enabled = TRUE))\n"
+            "captured <- NULL\n"
+            "postde_gsva_scores <- function(expr, gene_sets, method = 'gsva',\n"
+            "    min_size = 10, max_size = 500) {\n"
+            "    captured <<- c(min_size, max_size)\n"
+            "    matrix(0, nrow = 1, ncol = ncol(expr),\n"
+            "        dimnames = list('T1', colnames(expr)))\n"
+            "}\n"
+            "outdir <- tempfile()\n"
+            "dir.create(outdir)\n"
+            "invisible(postde_run_gsva(entry, term2gene, NULL, config, outdir))\n"
+            'cat("effective", captured[1], captured[2], "\\n")\n'
+        )
+        rfile = tmp_path / "defaults.R"
+        rfile.write_text(rcode)
+        result = subprocess.run(
+            [rscript, str(rfile)],
+            cwd=str(REPO / "scripts" / "Analysis" / "PostDE"),
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0, result.stderr[-2000:]
+        lines = [ln.split() for ln in result.stdout.strip().splitlines()]
+        assert lines[0] == ["global", "10", "500"]
+        assert lines[1] == ["gsva", "10", "500"]
+        assert lines[2] == ["effective", "10", "500"]
+
+
+class TestPostdeExecutable:
+    @pytest.mark.parametrize("engine", ["smk", "nf"])
+    @pytest.mark.parametrize("detool", ["deseq2", "edger"])
+    def test_postde_runs_real_run_r(self, workdir, tmp_path, engine, detool):
+        """Run the generated postde process/rule unmodified against the real
+        run.R with an offline decoupleR ULM/MLM analysis on a tiny bundle."""
+        rscript = shutil.which("Rscript")
+        if not rscript:
+            pytest.skip("Rscript not found on PATH")
+        resdir = tmp_path / "res dir"
+        resdir.mkdir()
+        (resdir / "network.tsv").write_text(
+            "source\ttarget\tmor\n"
+            "TF1\tG1\t1\n"
+            "TF1\tG2\t1\n"
+            "TF2\tG3\t-1\n"
+            "TF2\tG4\t-1\n"
+        )
+        analysis = {
+            "padj": 0.05,
+            "lfc": 1,
+            "min_size": 2,
+            "max_size": 500,
+            "decoupler": {
+                "enabled": True,
+                "network": "res dir/network.tsv",
+                "methods": ["ulm", "mlm"],
+                "min_size": 2,
+            },
+        }
+        cfg = _postde_cfg(tmp_path, analysis)
+        subdir = _generate_de(engine, workdir, cfg)
+        confo = json.load(
+            open(workdir / subdir / f"allconditions_DE_{detool}_subconfig.json")
+        )
+        assert confo["POSTDE"]["enabled"] is True
+        staged = confo["POSTDE"]["inputs"]
+        launch = workdir / "launch dir"
+        launch.mkdir()
+        bundle_src = _write_real_bundle(rscript, launch, detool)
+        if engine == "nf":
+            subflow = (
+                workdir / subdir / f"allconditions_DE_{detool}_subflow.nf"
+            ).read_text()
+            script = _extract_nf_script(subflow, "postde")
+            script = script.replace("\\$", "$")
+            script = script.replace("${params.gBINS}", str(REPO / "scripts"))
+            shutil.copy2(bundle_src, launch / "bundle")
+            os.symlink(workdir / staged, launch / "postde_inputs")
+            result = subprocess.run(
+                script, shell=True, cwd=str(launch), capture_output=True, text=True
+            )
+            assert result.returncode == 0, result.stderr[-2000:]
+            outdir = launch / "postde"
+            log = launch / "log"
+        else:
+            smk = (
+                workdir / subdir / f"allconditions_DE_{detool}_subsnake.smk"
+            ).read_text()
+            body = _extract_smk_rule_body(smk, "postde")
+            params_code, shell_tpl = _smk_params_shell(body)
+            combo = f"{detool}_DE"
+            ns = {"os": os, "combo": combo}
+            exec(params_code, ns)
+            fake_input = {
+                "bundle": [str(bundle_src)],
+                "staged": str(workdir / staged),
+                "config": str(workdir / staged / "config.json"),
+                "script": str(REPO / "scripts" / "Analysis" / "PostDE" / "run.R"),
+                "common": str(REPO / "scripts" / "Analysis" / "PostDE" / "common.R"),
+                "enrichment": str(
+                    REPO / "scripts" / "Analysis" / "PostDE" / "enrichment.R"
+                ),
+                "regulatory": str(
+                    REPO / "scripts" / "Analysis" / "PostDE" / "regulatory.R"
+                ),
+            }
+            old = os.getcwd()
+            os.chdir(launch)
+            try:
+                params = {
+                    "bundle": ns["bundle"](
+                        None, types.SimpleNamespace(**fake_input)
+                    ),
+                    "outdir": ns["outdir"](None),
+                }
+                log = os.path.abspath(
+                    os.path.join("LOGS", combo, "DE", detool, "postde.log")
+                )
+            finally:
+                os.chdir(old)
+            shell = _format_shell(
+                shell_tpl,
+                input=types.SimpleNamespace(**fake_input),
+                params=types.SimpleNamespace(**params),
+                log=log,
+            )
+            result = subprocess.run(
+                shell, shell=True, cwd=str(launch), capture_output=True, text=True
+            )
+            assert result.returncode == 0, result.stderr[-2000:]
+            outdir = launch / "POSTDE" / combo
+            log = launch / "LOGS" / combo / "DE" / detool / "postde.log"
         assert (outdir / "manifest.json").exists()
+        assert (outdir / "report_data.rds").exists()
+        entry = outdir / "A-VS-B"
+        for name in (
+            "decoupler_ulm_activities.tsv",
+            "decoupler_ulm_differential.tsv",
+            "decoupler_mlm_activities.tsv",
+            "decoupler_mlm_differential.tsv",
+            "decoupler_network_filtered.tsv",
+            "decoupler_design.tsv",
+            "decoupler_contrast.tsv",
+        ):
+            assert (entry / name).exists(), name
+        assert log.exists()
 
 
 class TestCliSave:
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 315f1421..3581f439 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -10,7 +10,7 @@ DECOMP = get_always('DECOMP') ?: ''
 DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
-PCOMBO = get_always('COMBO') ?: 'none'
+PCOMBO = COMBO ?: 'none'
 PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
@@ -232,11 +232,9 @@ process postde{
     path "log", emit: log
 
     script:
-    bundle = "${task.workDir}/bundle"
-    outdir = "${task.workDir}/postde"
-    logfile = "${task.workDir}/log"
     """
-    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "$bundle" --config "config.json" --output "$outdir") 2> "$logfile" && test -s "$outdir/manifest.json"
+    postde_workdir=\$PWD
+    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "\$postde_workdir/bundle" --config "config.json" --output "\$postde_workdir/postde") 2> "\$postde_workdir/log" && test -s "\$postde_workdir/postde/manifest.json"
     """
 }
 
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 753bd5fe..7856ed90 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -11,7 +11,7 @@ DECOMP = get_always('DECOMP') ?: ''
 DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
-PCOMBO = get_always('COMBO') ?: 'none'
+PCOMBO = COMBO ?: 'none'
 PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
@@ -233,11 +233,9 @@ process postde{
     path "log", emit: log
 
     script:
-    bundle = "${task.workDir}/bundle"
-    outdir = "${task.workDir}/postde"
-    logfile = "${task.workDir}/log"
     """
-    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "$bundle" --config "config.json" --output "$outdir") 2> "$logfile" && test -s "$outdir/manifest.json"
+    postde_workdir=\$PWD
+    (cd postde_inputs && Rscript "${BINS}/Analysis/PostDE/run.R" --bundle "\$postde_workdir/bundle" --config "config.json" --output "\$postde_workdir/postde") 2> "\$postde_workdir/log" && test -s "\$postde_workdir/postde/manifest.json"
     """
 }
 

From 8b8fb63749a05106b562a44cbd47ccb82916efd2 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 14:50:11 +0200
Subject: [PATCH 65/80] postde ready for testruns

---
 MONSDA/Configurator.py                        |  62 ++-
 MONSDA/Workflows.py                           |  20 +-
 MONSDA/web_configurator.py                    |  50 ++-
 configs/postde_analysis.json                  |  52 +++
 configs/template_base_commented.json          |   7 +-
 docs/source/config.rst                        | 119 ++++++
 docs/source/workflows.rst                     | 222 ++++++-----
 ...imgalore-picard-star_DTU_dexseq_subflow.nf |   2 +-
 ...mgalore-picard-star_DTU_drimseq_subflow.nf |   2 +-
 ...trimgalore-picard-star_DTU_spit_subflow.nf |   2 +-
 tests/test_Workflows.py                       |  75 ++++
 tests/test_postde_configurator.py             | 365 ++++++++++++++++++
 tests/test_postde_workflows.py                | 263 ++++++++-----
 workflows/deseq2_DE.nf                        |   2 +-
 workflows/deseq2_DE.smk                       |   2 +-
 workflows/edger_DE.nf                         |   2 +-
 workflows/edger_DE.smk                        |   2 +-
 17 files changed, 1028 insertions(+), 221 deletions(-)
 create mode 100644 configs/postde_analysis.json
 create mode 100644 tests/test_postde_configurator.py

diff --git a/MONSDA/Configurator.py b/MONSDA/Configurator.py
index d99eee43..95fe0e3b 100755
--- a/MONSDA/Configurator.py
+++ b/MONSDA/Configurator.py
@@ -17,6 +17,7 @@
 from snakemake.common.configfile import load_configfile
 
 from MONSDA.Logger import *
+from MONSDA.PostDE import load_postde_config
 
 from . import _version
 
@@ -34,7 +35,7 @@
 current_path = os.getcwd()
 
 template = load_configfile(os.sep.join([configpath, "template_base_commented.json"]))
-none_workflow_keys = ["WORKFLOWS", "BINS", "MAXTHREADS", "SETTINGS", "VERSION"]
+none_workflow_keys = ["WORKFLOWS", "BINS", "MAXTHREADS", "SETTINGS", "VERSION", "POSTDE"]
 comparable_workflows = ["DE", "DEU", "DAS", "DTU", "PEAKS"]
 quantifying_workflows = ["COUNTING"]
 IP_workflows = ["PEAKS"]
@@ -108,6 +109,7 @@ def __init__(self):
         self.workflowsDict = NestedDefaultDict()
         self.settingsDict = NestedDefaultDict()
         self.settingsList = []
+        self.postde = {"enabled": False, "config": ""}
 
 
 class GUIDE:
@@ -753,10 +755,12 @@ def add_workflows(existing_workflows=None):
     prGreen("\nADD WORKFLOWS\n")
     possible_workflows = list(project.baseDict.keys())
     for e in none_workflow_keys:
-        possible_workflows.remove(e)
+        if e in possible_workflows:
+            possible_workflows.remove(e)
     if existing_workflows:
         for e in existing_workflows:
-            possible_workflows.remove(e)
+            if e in possible_workflows:
+                possible_workflows.remove(e)
     posWorkDict = NestedDefaultDict()
     counter = 1
     for w in possible_workflows:
@@ -1275,11 +1279,16 @@ def modify(config=None):
         active_workflows = modify_config["WORKFLOWS"].split(",")
         inactive_workflows = list(modify_config.keys())
         for e in none_workflow_keys:
-            inactive_workflows.remove(e)
+            if e in inactive_workflows:
+                inactive_workflows.remove(e)
         for wf in inactive_workflows:
             project.workflowsDict[wf] = decouple(modify_config[wf])
         for e in modify_config["WORKFLOWS"].split(","):
-            inactive_workflows.remove(e)
+            if e in inactive_workflows:
+                inactive_workflows.remove(e)
+        project.postde = modify_config.get(
+            "POSTDE", {"enabled": False, "config": ""}
+        )
         prRed("\n   Following configuration was found :\n")
         prRed("   Condition-Tree:\n")
         print_dict(project.conditionsDict, gap="      ")
@@ -1300,7 +1309,8 @@ def modify(config=None):
         opts["2"] = "remove workflows"
         opts["3"] = "add conditions"
         opts["4"] = "remove conditions"
-        opts["5"] = "choose another file"
+        opts["5"] = "configure PostDE"
+        opts["6"] = "choose another file"
         guide.display(question="choose an option", options=opts, proof=opts.keys())
         guide.clear(3)
         if guide.answer == "1":
@@ -1312,6 +1322,8 @@ def modify(config=None):
         if guide.answer == "4":
             return remove_conditions()
         if guide.answer == "5":
+            return finalize()
+        if guide.answer == "6":
             project.settingsDict = NestedDefaultDict()
             project.conditionsDict = NestedDefaultDict()
             project.workflowsDict = NestedDefaultDict()
@@ -1752,6 +1764,43 @@ def set_cores():
     return finalize()
 
 
+def configure_postde(final_dict):
+    workflows = [
+        w.strip()
+        for w in str(final_dict.get("WORKFLOWS", "")).split(",")
+        if w.strip()
+    ]
+    if "DE" not in workflows:
+        final_dict["POSTDE"] = {"enabled": False, "config": ""}
+        return
+    current = getattr(project, "postde", {"enabled": False, "config": ""})
+    guide.display(
+        question="Enable PostDE analysis (GO/GSEA/GSVA/decoupleR/dream) after DE?",
+        proof=["yes", "no"],
+        spec="yes" if current.get("enabled") else "no",
+    )
+    if guide.answer.strip().lower() not in ("yes", "y"):
+        final_dict["POSTDE"] = {"enabled": False, "config": ""}
+        return
+    while True:
+        guide.display(
+            question="Enter the absolute path to the PostDE analysis JSON",
+            whitespace=True,
+            spec=current.get("config", ""),
+        )
+        path = guide.answer.strip()
+        if not path:
+            path = current.get("config", "")
+        try:
+            final_dict["POSTDE"] = load_postde_config(
+                {"enabled": True, "config": path}, config=final_dict
+            )
+            return
+        except ValueError as err:
+            prRed("PostDE config invalid: " + str(err))
+            continue
+
+
 def finalize():
     pickle_unfinished("finalize")
     final_dict = NestedDefaultDict()
@@ -1762,6 +1811,7 @@ def finalize():
     final_dict["VERSION"] = __version__
     final_dict["SETTINGS"] = project.settingsDict
     final_dict.update(project.workflowsDict)
+    configure_postde(final_dict)
 
     if project.subname:
         configfile = f"config_{'_'.join([project.name,project.subname])}.json"
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 2cdaa458..524e469a 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -112,15 +112,31 @@ def _nf_is_channel(rhs_list):
     return any("Channel." in r for r in rhs_list)
 
 
+_GA_LITERAL = re.compile(r"get_always\(\s*(['\"])((?:\\.|(?!\1)[^\\])*?)\1\s*\)")
+
+
 def _nf_rw(text, scalars, channels, ex_s=None, ex_c=None):
     """Rewrite bare references to global names: scalars -> params.gNAME,
-    channels -> NAME(). Interpolated forms handled as well."""
+    channels -> NAME(). Interpolated forms handled as well. Literal
+    get_always('KEY')/get_always("KEY") lookups are preserved byte-exact;
+    dynamic get_always(KEY) and GString arguments are rewritten as usual."""
     s_active = set(scalars) - ({ex_s} if ex_s else set())
     c_active = set(channels) - ({ex_c} if ex_c else set())
     alln = s_active | c_active
     if not alln:
         return text
 
+    ga = []
+
+    def _mask_ga(m):
+        if m.group(1) == '"' and "$" in m.group(2):
+            return m.group(0)
+        token = "\x00%d\x00" % len(ga)
+        ga.append(m.group(0))
+        return token
+
+    text = _GA_LITERAL.sub(_mask_ga, text)
+
     def repl(name, interp):
         if name in c_active:
             return ("${" + name + "()}") if interp else (name + "()")
@@ -138,6 +154,8 @@ def repl(name, interp):
         lambda m: repl(m.group(1), False),
         text,
     )
+    for i, orig in enumerate(ga):
+        text = text.replace("\x00%d\x00" % i, orig)
     return text
 
 
diff --git a/MONSDA/web_configurator.py b/MONSDA/web_configurator.py
index 86cc5407..12759d14 100644
--- a/MONSDA/web_configurator.py
+++ b/MONSDA/web_configurator.py
@@ -12,11 +12,12 @@
 
 from . import _version
 from .Params import samplesheet_to_settings
+from .PostDE import load_postde_config
 
 __version__ = _version.get_versions()["version"]
 
 TEMPLATE_FILE = "template_base_commented.json"
-NONE_WORKFLOW_KEYS = ["WORKFLOWS", "BINS", "MAXTHREADS", "SETTINGS", "VERSION"]
+NONE_WORKFLOW_KEYS = ["WORKFLOWS", "BINS", "MAXTHREADS", "SETTINGS", "VERSION", "POSTDE"]
 
 app = FastAPI(title="MONSDA Configurator Web")
 
@@ -41,6 +42,7 @@ class BuildConfigRequest(BaseModel):
     maxthreads: str = "16"
     settings: Optional[Dict[str, Any]] = None
     samplesheet_path: Optional[str] = None
+    postde: Optional[Dict[str, Any]] = None
 
 
 class ConditionFiles(BaseModel):
@@ -243,6 +245,16 @@ def build_config(req: BuildConfigRequest) -> Dict[str, Any]:
             req.tools.get(wf, []),
         )
 
+    if req.postde is None:
+        final_config["POSTDE"] = {"enabled": False, "config": ""}
+    else:
+        try:
+            final_config["POSTDE"] = load_postde_config(
+                req.postde, config=final_config
+            )
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+
     return final_config
 
 
@@ -355,9 +367,16 @@ def save_config(req: SaveConfigRequest) -> Dict[str, Any]:
     if not os.path.isdir(output_dir):
         raise HTTPException(status_code=400, detail="Output directory does not exist.")
 
+    config = copy.deepcopy(req.config)
+    if "POSTDE" in config:
+        try:
+            config["POSTDE"] = load_postde_config(config["POSTDE"], config=config)
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+
     path = os.path.join(output_dir, f"config_{config_name}.json")
     with open(path, "w") as fh:
-        json.dump(req.config, fh, indent=4)
+        json.dump(config, fh, indent=4)
 
     return {"message": "Config written.", "path": path}
 
@@ -367,6 +386,15 @@ def create_project(req: ProjectRequest) -> Dict[str, Any]:
     base_dir = os.path.abspath(req.project_dir.strip())
     project_name = req.project_name.strip() or "monsda"
 
+    # Validate POSTDE before any creation/writes
+    if req.config and "POSTDE" in req.config:
+        try:
+            req.config["POSTDE"] = load_postde_config(
+                req.config["POSTDE"], config=req.config
+            )
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+
     # Project name becomes a subdirectory under the chosen path
     project_dir = os.path.join(base_dir, project_name)
     os.makedirs(project_dir, exist_ok=True)
@@ -734,6 +762,16 @@ def root() -> str:
     <div id="templateStatus" class="muted"></div>
     <div id="workflowSummary" class="muted"></div>
     <div id="workflowChooser" class="workflow-grid"></div>
+    <div style="margin-top:14px; border-top:1px solid #e2e8f0; padding-top:12px;">
+      <label class="wf-chip" style="display:inline-flex; margin-bottom:6px;">
+        <input type="checkbox" id="postdeEnabled" /> PostDE (GO/GSEA/GSVA/decoupleR/dream)
+      </label>
+      <div class="muted" style="margin-bottom:8px;">Runs enrichment/regulatory analysis on DE results. DESeq2/edgeR only, requires the DE workflow.</div>
+      <div class="pathline">
+        <input id="postdeConfig" placeholder="/abs/path/to/postde_analysis.json" />
+        <button type="button" onclick="openPathBrowser('postdeConfig','all')">Browse...</button>
+      </div>
+    </div>
   </div>
 
   <div class="card">
@@ -946,7 +984,7 @@ def root() -> str:
     holder.innerHTML = '';
 
     const workflows = Object.keys(data)
-      .filter(k => !['WORKFLOWS','BINS','MAXTHREADS','SETTINGS','VERSION'].includes(k))
+      .filter(k => !['WORKFLOWS','BINS','MAXTHREADS','SETTINGS','VERSION','POSTDE'].includes(k))
       .sort();
 
     workflows.forEach(wf => {
@@ -1256,7 +1294,11 @@ def root() -> str:
       tools: tools,
       maxthreads: document.getElementById('maxthreads').value.trim(),
       settings: settings,
-      samplesheet_path: document.getElementById('samplesheetPath').value.trim() || null
+      samplesheet_path: document.getElementById('samplesheetPath').value.trim() || null,
+      postde: {
+        enabled: document.getElementById('postdeEnabled').checked,
+        config: document.getElementById('postdeConfig').value.trim()
+      }
     };
 
     const r = await fetch('/config/preview', {
diff --git a/configs/postde_analysis.json b/configs/postde_analysis.json
new file mode 100644
index 00000000..90f96c7a
--- /dev/null
+++ b/configs/postde_analysis.json
@@ -0,0 +1,52 @@
+{
+  "padj": 0.05,
+  "lfc": 1,
+  "seed": 42,
+  "min_size": 10,
+  "max_size": 500,
+  "gprofiler": {
+    "enabled": true,
+    "organism": "hsapiens",
+    "domain_scope": "custom",
+    "allow_network": true,
+    "sources": ["GO:BP", "GO:MF", "GO:CC", "REAC"],
+    "correction_method": "g_SCS",
+    "background": null
+  },
+  "clusterprofiler": {
+    "enabled": false,
+    "go_expand": false,
+    "term2gene": null,
+    "term2name": null,
+    "background": null
+  },
+  "gsva": {
+    "enabled": false,
+    "method": "gsva"
+  },
+  "decoupler": {
+    "enabled": false,
+    "resource": "collectri",
+    "organism": "human",
+    "top": 500,
+    "min_size": 10,
+    "methods": ["ulm", "mlm"],
+    "contrast_activity": false,
+    "allow_network": false,
+    "network": null
+  },
+  "dream": {
+    "enabled": false,
+    "formula": "~condition + (1|subject)",
+    "metadata": null
+  },
+  "plots": {
+    "enabled": false
+  },
+  "report": {
+    "enabled": false
+  },
+  "shiny": {
+    "enabled": false
+  }
+}
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index 649f4cd9..951393c8 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -3,12 +3,17 @@
     "WORKFLOWS": "Select workflows you want to run, possible values: FETCH, MAPPING, QC, DEDUP, TRIMMING, COUNTING, TRACKS, PEAKS, DE, DEU, DAS, DTU, CIRCS, FUSIONS",
     "BINS": "Where to find the scripts used in the workflow, per default the scripts directory that comes with MONSDA. ONLY CHANGE IF YOU KNOW WHAT YOU ARE DOING!",
     "MAXTHREADS": "Maximum number of cores to use, make sure this fits your needs, acts as upper cap.",
-    "VERSION": "Version of MONSDA to use, needs to match installed version"
+    "VERSION": "Version of MONSDA to use, needs to match installed version",
+    "POSTDE": "Optional post-DE enrichment/regulatory analysis (GO/GSEA/GSVA/decoupleR/dream). Disabled by default. When enabled, 'config' must point to a PostDE analysis JSON (see configs/postde_analysis.json). Only supported with the DE workflow and the deseq2/edger DE tools."
   },
   "WORKFLOWS": "",
   "BINS": "MONSDA/scripts",
   "MAXTHREADS": "",
   "VERSION": "",
+  "POSTDE": {
+    "enabled": false,
+    "config": ""
+  },
   "SETTINGS": {
     "comment": {
       "GROUPS": "Please enter a comma separated list of the groups your samples belong to. This does not have to be in any relation with the condition-tree but is used solely to establish contrasts for differential analysis. Each sample needs a matching entry. Can be left blank to run all-vs-all comparison.",
diff --git a/docs/source/config.rst b/docs/source/config.rst
index bb918afe..b1c2cd18 100644
--- a/docs/source/config.rst
+++ b/docs/source/config.rst
@@ -112,3 +112,122 @@ Another special case is 'MACS', a peak caller for ChIP-Seq data, which needs to
 For everything else please refer to the :ref:`tutorials`, the :ref:`condition-tree<condition-tree>` and the :ref:`Workflow Overview<WFoverview>`.
 
 Keep in mind that every workflow step needs a corresponding entry in the config file or **MONSDA.py** will throw an error.
+
+PostDE (GO/GSEA/GSVA/decoupleR/dream)
+=====================================
+
+PostDE is an optional post-processing step that runs enrichment (GO/GSEA via gProfiler or clusterProfiler), gene-set variation analysis (GSVA) and regulatory inference (decoupleR ULM/MLM, variancePartition dream) on the results of a DE analysis. It is **disabled by default** and only supported together with the **DE** workflow and the **deseq2**/**edger** DE tools (DEU/DTU/DAS are not supported).
+
+Enable it in the top-level of the config file, next to ``WORKFLOWS``, ``DE`` and the DE ``TOOLS`` (which stay unchanged):
+
+.. code-block:: json
+
+    {
+      "WORKFLOWS": "DE",
+      "DE": {
+        "TOOLS": {
+          "deseq2": "Analysis/DE/DESEQ2.R",
+          "edger": "Analysis/DE/EDGER.R"
+        }
+      },
+      "POSTDE": {
+        "enabled": true,
+        "config": "/abs/path/to/postde_analysis.json"
+      }
+    }
+
+The ``POSTDE.config`` path is resolved relative to the **run working directory** (the directory you launch ``monsda`` from). Resource files referenced inside the analysis JSON (``term2gene``, ``background``, ``network``, ``metadata``) are resolved relative to the directory of the analysis JSON itself. The analysis JSON is validated at startup and again when the DE sub-workflow is prepared; an invalid config aborts the run with a clear error.
+
+Analysis JSON schema
+--------------------
+
+The analysis JSON supports the following top-level keys (all optional unless noted):
+
+.. code-block:: json
+
+    {
+      "padj": 0.05,
+      "lfc": 1,
+      "seed": 1,
+      "min_size": 10,
+      "max_size": 500,
+      "gprofiler": { "enabled": false },
+      "clusterprofiler": { "enabled": false },
+      "gsva": { "enabled": false },
+      "decoupler": { "enabled": false },
+      "dream": { "enabled": false },
+      "plots": { "enabled": false },
+      "report": { "enabled": false },
+      "shiny": { "enabled": false }
+    }
+
+Defaults (read from the actual R implementation): ``padj=0.05``, ``lfc=1``, ``seed=1``, ``min_size=10``, ``max_size=500``. ``padj``/``lfc`` are the PostDE significance cutoffs used to define the significant gene sets for ORA; they are **independent of** the ``DE.CUTOFFS`` in the DE section. GSEA always consumes the **full ranked gene list** and is never filtered by ``padj``/``lfc``.
+
+Per-method keys:
+
+* ``gprofiler``: ``enabled``, ``organism`` (required when enabled, e.g. ``hsapiens``), ``domain_scope`` (``annotated``, ``known``, ``custom``, ``custom_annotated``; default ``custom``), ``allow_network`` (required ``true``, gost is an online call), ``sources`` (list, e.g. ``["GO:BP", "GO:MF", "GO:CC", "REAC"]``; default all), ``correction_method`` (default ``g_SCS``), ``background`` (optional file, one gene ID per row, no header).
+* ``clusterprofiler``: ``enabled``, ``term2gene`` (required when clusterprofiler or gsva is enabled), ``term2name`` (optional), ``go_expand`` (optional boolean, builds a GO map via ``buildGOmap``), ``background`` (optional file, one gene ID per row, no header).
+* ``gsva``: ``enabled``, ``method`` (``gsva`` or ``ssgsea``; default ``gsva``), ``min_size``/``max_size`` (default to the top-level values).
+* ``decoupler``: ``enabled``, ``network`` (offline network file) **or** ``allow_network`` (retrieve from OmniPath), ``source_col``/``target_col``/``mor_col`` (default ``source``/``target``/``mor``), ``resource`` (``collectri`` or ``progeny``; default ``collectri``), ``organism`` (default ``human``), ``top`` (PROGENy top pathways, default ``500``), ``min_size`` (default top-level), ``methods`` (``ulm`` and/or ``mlm``; default both), ``contrast_activity`` (optional boolean).
+* ``dream``: ``enabled``, ``metadata`` (required when enabled; TSV with a ``sample`` column, **no** ``condition`` column), ``formula`` (required when enabled, must include a random effect, e.g. ``~condition + (1|subject)``), ``contrasts`` (optional).
+* ``plots``/``report``/``shiny``: only ``enabled``; setting ``enabled=true`` is rejected because the HTML reporting layer is not provided yet.
+
+A ready-to-use online example (human) is shipped as ``configs/postde_analysis.json`` in the repository. It enables gProfiler with ``organism=hsapiens``, ``domain_scope=custom``, ``allow_network=true`` and the sources ``GO:BP``, ``GO:MF``, ``GO:CC``, ``REAC``; all other methods are disabled and no resource files are required. Change the organism for non-human data — the example is not universal.
+
+Offline example (clusterProfiler + GSVA)
+----------------------------------------
+
+For offline runs (no gProfiler network access) use clusterProfiler/GSVA with a custom ``term2gene`` file. The file must have a header with exactly the columns ``term`` and ``gene``:
+
+.. code-block:: text
+
+    term    gene
+    GO:0008150   GENE1
+    GO:0008150   GENE2
+    GO:0009987   GENE1
+
+An optional ``term2name`` file has the header ``term`` and ``name``; an optional ``background`` file has one gene ID per row and no header. A decoupler ``network`` file has the columns ``source``, ``target``, ``mor``; a dream ``metadata`` file has a ``sample`` column and no ``condition`` column.
+
+.. code-block:: json
+
+    {
+      "padj": 0.05,
+      "lfc": 1,
+      "seed": 42,
+      "min_size": 10,
+      "max_size": 500,
+      "clusterprofiler": {
+        "enabled": true,
+        "term2gene": "term2gene.tsv",
+        "term2name": "term2name.tsv",
+        "background": "background.txt"
+      },
+      "gsva": {
+        "enabled": true,
+        "method": "gsva"
+      },
+      "gprofiler": { "enabled": false },
+      "decoupler": { "enabled": false },
+      "dream": { "enabled": false },
+      "plots": { "enabled": false },
+      "report": { "enabled": false },
+      "shiny": { "enabled": false }
+    }
+
+Running PostDE
+--------------
+
+From a populated project root (raw BAMs and a completed DE run are prerequisites, see the DE section of the :ref:`Workflow Overview<WFoverview>`), with the root ``POSTDE`` path enabled and the config ``VERSION`` matching the installed MONSDA version:
+
+.. code-block:: bash
+
+    monsda -c config_monsda.json -d . -j 8
+
+Add ``--nextflow`` to run the Nextflow engine or ``--save`` to keep intermediate files. The CLI flags ``-d``/``-j`` are supported by the existing runner (covered by the test suite).
+
+Environment
+-----------
+
+The PostDE R code needs the ``postde`` conda environment (``envs/postde.yaml`` in the repository). A container recipe exists (``containers/apptainer/postde.def``) and builds from that environment file, but no image is published yet — prefer the conda route until a local/cluster container build is available.
+
+The interactive Configurator (``monsda_configure``) can enable PostDE when creating or modifying a config: it asks for the analysis JSON path when the DE workflow is active, and the modify menu offers a dedicated *configure PostDE* option. The web Configurator exposes the same option as a checkbox next to the workflow selection.
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index 345a02e3..8c944367 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -63,13 +63,13 @@ Creates FASTQ files from ONT FAST5, Guppy needs to be installed locally
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +-------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+---------------------+------------------------------------------------------------------------+--------+---------+
-  | TOOL  | DESCRIPTION                                                                                                                                                                                                                                                                | ENV    | BIN                 | LINK                                                                   | INPUT  | OUTPUT  |
-  +=======+============================================================================================================================================================================================================================================================================+========+=====================+========================================================================+========+=========+
-  | Guppy | Data processing toolkit that contains Oxford Nanopore’s basecalling algorithms, and several bioinformatic post-processing features, such as barcoding/demultiplexing, adapter trimming, and alignment. Needs to be installed locally as no **conda** version is available  | guppy  | $PATH_TO_LOCAL_BIN  | `guppy <https://nanoporetech.com/nanopore-sequencing-data-analysis>`_  | FAST5  | FASTQ   |
-  +-------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+---------------------+------------------------------------------------------------------------+--------+---------+
-  | Dorado | Dorado is a high-performance, easy-to-use, open source basecaller for Oxford Nanopore reads. Needs to be installed locally as no **conda** version is available  | dorado  | $PATH_TO_LOCAL_BIN  | `dorado <https://github.com/nanoporetech/dorado>`_  | POD5  | FASTQ   |
-  +-------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+---------------------+------------------------------------------------------------------------+--------+---------+
+  +--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+--------------------+-----------------------------------------------------------------------+-------+--------+
+  | TOOL   | DESCRIPTION                                                                                                                                                                                                                                                               | ENV    | BIN                | LINK                                                                  | INPUT | OUTPUT |
+  +========+===========================================================================================================================================================================================================================================================================+========+====================+=======================================================================+=======+========+
+  | Guppy  | Data processing toolkit that contains Oxford Nanopore’s basecalling algorithms, and several bioinformatic post-processing features, such as barcoding/demultiplexing, adapter trimming, and alignment. Needs to be installed locally as no **conda** version is available | guppy  | $PATH_TO_LOCAL_BIN | `guppy <https://nanoporetech.com/nanopore-sequencing-data-analysis>`_ | FAST5 | FASTQ  |
+  +--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+--------------------+-----------------------------------------------------------------------+-------+--------+
+  | Dorado | Dorado is a high-performance, easy-to-use, open source basecaller for Oxford Nanopore reads. Needs to be installed locally as no **conda** version is available                                                                                                           | dorado | $PATH_TO_LOCAL_BIN | `dorado <https://github.com/nanoporetech/dorado>`_                    | POD5  | FASTQ  |
+  +--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------+--------------------+-----------------------------------------------------------------------+-------+--------+
   
 
 QUALITY CONTROL I
@@ -81,13 +81,13 @@ This workflow step can be run as preprocessing step if none of the processing wo
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
-  | TOOL                       | DESCRIPTION                                                | ENV     | BIN     | LINK                                                                    | INPUT      | OUTPUT    |
-  +============================+============================================================+=========+=========+=========================================================================+============+===========+
-  | FASTQC (includes MULTIQC)  | A quality control tool for high throughput sequence data.  | fastqc  | fastqc  | `fastqc <https://www.bioinformatics.babraham.ac.uk/projects/fastqc/>`_  | FASTQ/BAM  | ZIP/HTML  |
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
-  | RustQC (includes MULTIQC)  | High-performance RNA-seq QC suite with MultiQC-compatible outputs. | rustqc  | rustqc  | `rustqc <https://github.com/seqeralabs/RustQC>`_  | BAM  | TEXT/TSV/LOG  |
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
+  | TOOL                      | DESCRIPTION                                                        | ENV    | BIN    | LINK                                                                   | INPUT     | OUTPUT       |
+  +===========================+====================================================================+========+========+========================================================================+===========+==============+
+  | FASTQC (includes MULTIQC) | A quality control tool for high throughput sequence data.          | fastqc | fastqc | `fastqc <https://www.bioinformatics.babraham.ac.uk/projects/fastqc/>`_ | FASTQ/BAM | ZIP/HTML     |
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
+  | RustQC (includes MULTIQC) | High-performance RNA-seq QC suite with MultiQC-compatible outputs. | rustqc | rustqc | `rustqc <https://github.com/seqeralabs/RustQC>`_                       | BAM       | TEXT/TSV/LOG |
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
   
 
 PROCESSING
@@ -102,13 +102,13 @@ If any of the below listed processing steps is defined in the config.json, quali
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
-  | TOOL                       | DESCRIPTION                                                | ENV     | BIN     | LINK                                                                    | INPUT      | OUTPUT    |
-  +============================+============================================================+=========+=========+=========================================================================+============+===========+
-  | FASTQC (includes MULTIQC)  | A quality control tool for high throughput sequence data.  | fastqc  | fastqc  | `fastqc <https://www.bioinformatics.babraham.ac.uk/projects/fastqc/>`_  | FASTQ/BAM  | ZIP/HTML  |
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
-  | RustQC (includes MULTIQC)  | High-performance RNA-seq QC suite with MultiQC-compatible outputs. | rustqc  | rustqc  | `rustqc <https://github.com/seqeralabs/RustQC>`_  | BAM  | TEXT/TSV/LOG  |
-  +----------------------------+------------------------------------------------------------+---------+---------+-------------------------------------------------------------------------+------------+-----------+
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
+  | TOOL                      | DESCRIPTION                                                        | ENV    | BIN    | LINK                                                                   | INPUT     | OUTPUT       |
+  +===========================+====================================================================+========+========+========================================================================+===========+==============+
+  | FASTQC (includes MULTIQC) | A quality control tool for high throughput sequence data.          | fastqc | fastqc | `fastqc <https://www.bioinformatics.babraham.ac.uk/projects/fastqc/>`_ | FASTQ/BAM | ZIP/HTML     |
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
+  | RustQC (includes MULTIQC) | High-performance RNA-seq QC suite with MultiQC-compatible outputs. | rustqc | rustqc | `rustqc <https://github.com/seqeralabs/RustQC>`_                       | BAM       | TEXT/TSV/LOG |
+  +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
 
 
 Trimming
@@ -120,17 +120,17 @@ Trims adaptor left-overs from fastq files
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+--------------+----------------------------------------------------------------------------------+--------+----------------+
-  | TOOL         | DESCRIPTION                                                                                                                                                                                                              | ENV         | BIN          | LINK                                                                             | INPUT  | OUTPUT         |
-  +==============+==========================================================================================================================================================================================================================+=============+==============+==================================================================================+========+================+
-  | trim_galore  | A wrapper tool around Cutadapt and FastQC to consistently apply quality and adapter trimming to FastQ files, with some extra functionality for MspI-digested RRBS-type (Reduced Representation Bisufite-Seq) libraries.  | trimgalore  | trim_galore  | `trimgalore <https://www.bioinformatics.babraham.ac.uk/projects/trim_galore/>`_  | FASTQ  | TRIMMED_FASTQ  |
-  +--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+--------------+----------------------------------------------------------------------------------+--------+----------------+
-  | cutadapt     | Cutadapt finds and removes adapter sequences, primers, poly-A tails and other types of unwanted sequence from your high-throughput sequencing reads.                                                                     | cutadapt    | cutadapt     | `cutadapt <https://cutadapt.readthedocs.io/en/stable/>`_                         | FASTQ  | TRIMMED_FASTQ  |
-  +--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+--------------+----------------------------------------------------------------------------------+--------+----------------+
-  | bbduk     |    “Duk” stands for Decontamination Using Kmers. BBDuk was developed to combine most common data-quality-related trimming, filtering, and masking operations into a single high-performance tool.                                                                  | bbduk    | bbduk     | `bbduk <https://jgi.doe.gov/data-and-tools/software-tools/bbtools/bb-tools-user-guide/bbduk-guide/>`_                         | FASTQ  | TRIMMED_FASTQ  |
-  +--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+--------------+----------------------------------------------------------------------------------+--------+----------------+
-  | fastp     |    A tool designed to provide fast all-in-one preprocessing for FastQ files. This tool is developed in C++ with multithreading supported to afford high performance.                                                                  | fastp   | fastp     | `fastp <https://github.com/OpenGene/fastp>`_                         | FASTQ  | TRIMMED_FASTQ  |
-  +--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+--------------+----------------------------------------------------------------------------------+--------+----------------+
+  +-------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-------------------------------------------------------------------------------------------------------+-------+---------------+
+  | TOOL        | DESCRIPTION                                                                                                                                                                                                             | ENV        | BIN         | LINK                                                                                                  | INPUT | OUTPUT        |
+  +=============+=========================================================================================================================================================================================================================+============+=============+=======================================================================================================+=======+===============+
+  | trim_galore | A wrapper tool around Cutadapt and FastQC to consistently apply quality and adapter trimming to FastQ files, with some extra functionality for MspI-digested RRBS-type (Reduced Representation Bisufite-Seq) libraries. | trimgalore | trim_galore | `trimgalore <https://www.bioinformatics.babraham.ac.uk/projects/trim_galore/>`_                       | FASTQ | TRIMMED_FASTQ |
+  +-------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-------------------------------------------------------------------------------------------------------+-------+---------------+
+  | cutadapt    | Cutadapt finds and removes adapter sequences, primers, poly-A tails and other types of unwanted sequence from your high-throughput sequencing reads.                                                                    | cutadapt   | cutadapt    | `cutadapt <https://cutadapt.readthedocs.io/en/stable/>`_                                              | FASTQ | TRIMMED_FASTQ |
+  +-------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-------------------------------------------------------------------------------------------------------+-------+---------------+
+  | bbduk       | “Duk” stands for Decontamination Using Kmers. BBDuk was developed to combine most common data-quality-related trimming, filtering, and masking operations into a single high-performance tool.                          | bbduk      | bbduk       | `bbduk <https://jgi.doe.gov/data-and-tools/software-tools/bbtools/bb-tools-user-guide/bbduk-guide/>`_ | FASTQ | TRIMMED_FASTQ |
+  +-------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-------------------------------------------------------------------------------------------------------+-------+---------------+
+  | fastp       | A tool designed to provide fast all-in-one preprocessing for FastQ files. This tool is developed in C++ with multithreading supported to afford high performance.                                                       | fastp      | fastp       | `fastp <https://github.com/OpenGene/fastp>`_                                                          | FASTQ | TRIMMED_FASTQ |
+  +-------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-------------------------------------------------------------------------------------------------------+-------+---------------+
 
 
 Mapping
@@ -142,35 +142,35 @@ Maps sequences to reference genomes or transcriptomes
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | TOOL         | DESCRIPTION                                                                                                                | ENV                  | BIN         | LINK                                                                | INPUT                | OUTPUT      |
-  +==============+============================================================================================================================+======================+=============+=====================================================================+======================+=============+
-  | HISAT2       | HISAT2 is a fast and sensitive alignment program                                                                           | hisat2               | hisat2      | `hisat2 <http://daehwankimlab.github.io/hisat2/manual/>`_           | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | STAR         | Spliced Transcripts Alignment to a Reference                                                                               | star                 | STAR        | `star <https://github.com/alexdobin/STAR>`_                         | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | rustar       | Pure-Rust reimplementation of STAR, drop-in replacement with STAR-compatible CLI and index                                 | rustar               | rustar      | `rustar-aligner <https://github.com/scverse/rustar-aligner>`_       | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | STARsolo        | STARsolo: mapping, demultiplexing and quantification for single cell RNA-seq                                                                               | star                 | STAR        | `STARsolo <https://github.com/alexdobin/STAR/blob/master/docs/STARsolo.md>`_                         | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | Segemehl2|3  | Segemehl is a software to map short sequencer reads to reference genomes.                                                  | segemehl2/segemehl3  | segemehl.x  | `segemehl <https://www.bioinf.uni-leipzig.de/Software/segemehl/>`_  | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | Segemehl2|3 bisulfite | Segemehl is a software to map short sequencer reads to reference genomes. This is the bisulfite mapping mode                                                  | segemehl2bisulfite/segemehl3bisulfite  | segemehl.x  | `segemehl <https://www.bioinf.uni-leipzig.de/Software/segemehl/>`_  | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | BWA          | BWA is a software package for mapping low-divergent sequences against a large reference genome                             | bwa                  | bwa mem     | `bwa <http://bio-bwa.sourceforge.net/>`_                            | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | BWA2          | BWA is a software package for mapping low-divergent sequences against a large reference genome                             | bwa2                  | bwa2-mem     | `bwa2 <https://github.com/bwa-mem2/bwa-mem2>`_                            | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-  | BWA-Meth          | BWA-meth, Fast and accurante alignment of BS-Seq reads.                             | bwameth               | bwameth.py     | `bwa-meth <https://github.com/brentp/bwa-meth>`_                            | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-  +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-   | Minimap2     | Minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database. Use ``-x map-ont``/``-x map-pb`` for long-read (Nanopore/PacBio) mapping.   | minimap              | minimap2    | `minimap <https://github.com/lh3/minimap2>`_                        | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-   | salmonalign  | Salmon selective-alignment used as a mapper (``salmon quant --writeMappings``). Reuses the salmon environment/container.   | salmonalign          | salmon      | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_     | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-   | rammap       | Rust-accelerated long-read (Nanopore/PacBio) mapper (cargo-built, not on bioconda).                                        | rammap               | rammap      | `rammap <https://github.com/jwanglab/rammap>`_                      | FASTQ/TRIMMED_FASTQ  | SAM.gz/BAM  |
-   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
-   | piscem       | Fast single-cell/bulk mapper producing a RAD file for downstream alevin-fry quantification (single-cell only).             | piscem               | piscem      | `piscem <https://github.com/COMBINE-lab/piscem>`_                   | FASTQ/TRIMMED_FASTQ  | RAD         |
-   +--------------+----------------------------------------------------------------------------------------------------------------------------+----------------------+-------------+---------------------------------------------------------------------+----------------------+-------------+
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | TOOL                  | DESCRIPTION                                                                                                                                                                                        | ENV                                   | BIN        | LINK                                                                         | INPUT               | OUTPUT     |
+  +=======================+====================================================================================================================================================================================================+=======================================+============+==============================================================================+=====================+============+
+  | HISAT2                | HISAT2 is a fast and sensitive alignment program                                                                                                                                                   | hisat2                                | hisat2     | `hisat2 <http://daehwankimlab.github.io/hisat2/manual/>`_                    | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | STAR                  | Spliced Transcripts Alignment to a Reference                                                                                                                                                       | star                                  | STAR       | `star <https://github.com/alexdobin/STAR>`_                                  | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | rustar                | Pure-Rust reimplementation of STAR, drop-in replacement with STAR-compatible CLI and index                                                                                                         | rustar                                | rustar     | `rustar-aligner <https://github.com/scverse/rustar-aligner>`_                | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | STARsolo              | STARsolo: mapping, demultiplexing and quantification for single cell RNA-seq                                                                                                                       | star                                  | STAR       | `STARsolo <https://github.com/alexdobin/STAR/blob/master/docs/STARsolo.md>`_ | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | Segemehl2|3           | Segemehl is a software to map short sequencer reads to reference genomes.                                                                                                                          | segemehl2/segemehl3                   | segemehl.x | `segemehl <https://www.bioinf.uni-leipzig.de/Software/segemehl/>`_           | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | Segemehl2|3 bisulfite | Segemehl is a software to map short sequencer reads to reference genomes. This is the bisulfite mapping mode                                                                                       | segemehl2bisulfite/segemehl3bisulfite | segemehl.x | `segemehl <https://www.bioinf.uni-leipzig.de/Software/segemehl/>`_           | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | BWA                   | BWA is a software package for mapping low-divergent sequences against a large reference genome                                                                                                     | bwa                                   | bwa mem    | `bwa <http://bio-bwa.sourceforge.net/>`_                                     | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | BWA2                  | BWA is a software package for mapping low-divergent sequences against a large reference genome                                                                                                     | bwa2                                  | bwa2-mem   | `bwa2 <https://github.com/bwa-mem2/bwa-mem2>`_                               | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | BWA-Meth              | BWA-meth, Fast and accurante alignment of BS-Seq reads.                                                                                                                                            | bwameth                               | bwameth.py | `bwa-meth <https://github.com/brentp/bwa-meth>`_                             | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | Minimap2              | Minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database. Use ``-x map-ont``/``-x map-pb`` for long-read (Nanopore/PacBio) mapping. | minimap                               | minimap2   | `minimap <https://github.com/lh3/minimap2>`_                                 | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | salmonalign           | Salmon selective-alignment used as a mapper (``salmon quant --writeMappings``). Reuses the salmon environment/container.                                                                           | salmonalign                           | salmon     | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_              | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | rammap                | Rust-accelerated long-read (Nanopore/PacBio) mapper (cargo-built, not on bioconda).                                                                                                                | rammap                                | rammap     | `rammap <https://github.com/jwanglab/rammap>`_                               | FASTQ/TRIMMED_FASTQ | SAM.gz/BAM |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
+  | piscem                | Fast single-cell/bulk mapper producing a RAD file for downstream alevin-fry quantification (single-cell only).                                                                                     | piscem                                | piscem     | `piscem <https://github.com/COMBINE-lab/piscem>`_                            | FASTQ/TRIMMED_FASTQ | RAD        |
+  +-----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------+------------+------------------------------------------------------------------------------+---------------------+------------+
 
 
 DEDUP
@@ -205,21 +205,21 @@ Count (unique) mapped reads and how often they map to defined features
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-  | TOOL           | DESCRIPTION                                                                                                           | ENV         | BIN            | LINK                                                             | INPUT                | OUTPUT  |
-  +================+=======================================================================================================================+=============+================+==================================================================+======================+=========+
-  | FeatureCounts  | A software program developed for counting reads to genomic features such as genes, exons, promoters and genomic bins  | countreads  | featureCounts  | `featurecounts <http://subread.sourceforge.net/>`_               | BAM/FASTQ            | TEXT    |
-  +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-   | Salmon         | Salmon is a tool for wicked-fast transcript quantification from RNA-seq data. Also supports quantification directly from an alignment BAM via the ``BAM`` option (``transcriptome`` or ``genome``).  | salmon      | salmon         | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_  | FASTQ/TRIMMED_FASTQ/BAM  | TEXT    |
-   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-   | Kallisto         | Kallisto is a program for quantifying abundances of transcripts from bulk and single-cell RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads. | kallisto      | kallisto         | `kallisto <https://pachterlab.github.io/kallisto/manual>`_  | FASTQ/TRIMMED_FASTQ  | TEXT    |
-   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-   | oarfish        | Long-read (Nanopore/PacBio) transcript quantification from a transcriptome-aligned BAM.                               | oarfish     | oarfish        | `oarfish <https://github.com/COMBINE-lab/oarfish>`_             | BAM                  | TEXT    |
-   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-   | alevin-fry     | Single-cell quantification consuming a piscem RAD file to produce a count matrix.                                     | alevinfry   | alevin-fry     | `alevin-fry <https://github.com/COMBINE-lab/alevin-fry>`_       | RAD                  | MATRIX  |
-   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
-   | simpleaf       | Self-contained single-cell quantification wrapper (index + map + quant) around salmon/alevin-fry.                     | simpleaf    | simpleaf       | `simpleaf <https://github.com/COMBINE-lab/simpleaf>`_           | FASTQ/TRIMMED_FASTQ  | MATRIX  |
-   +----------------+-----------------------------------------------------------------------------------------------------------------------+-------------+----------------+------------------------------------------------------------------+----------------------+---------+
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | TOOL          | DESCRIPTION                                                                                                                                                                                         | ENV        | BIN           | LINK                                                            | INPUT                   | OUTPUT |
+  +===============+=====================================================================================================================================================================================================+============+===============+=================================================================+=========================+========+
+  | FeatureCounts | A software program developed for counting reads to genomic features such as genes, exons, promoters and genomic bins                                                                                | countreads | featureCounts | `featurecounts <http://subread.sourceforge.net/>`_              | BAM/FASTQ               | TEXT   |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | Salmon        | Salmon is a tool for wicked-fast transcript quantification from RNA-seq data. Also supports quantification directly from an alignment BAM via the ``BAM`` option (``transcriptome`` or ``genome``). | salmon     | salmon        | `salmon <https://salmon.readthedocs.io/en/latest/salmon.html>`_ | FASTQ/TRIMMED_FASTQ/BAM | TEXT   |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | Kallisto      | Kallisto is a program for quantifying abundances of transcripts from bulk and single-cell RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads.               | kallisto   | kallisto      | `kallisto <https://pachterlab.github.io/kallisto/manual>`_      | FASTQ/TRIMMED_FASTQ     | TEXT   |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | oarfish       | Long-read (Nanopore/PacBio) transcript quantification from a transcriptome-aligned BAM.                                                                                                             | oarfish    | oarfish       | `oarfish <https://github.com/COMBINE-lab/oarfish>`_             | BAM                     | TEXT   |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | alevin-fry    | Single-cell quantification consuming a piscem RAD file to produce a count matrix.                                                                                                                   | alevinfry  | alevin-fry    | `alevin-fry <https://github.com/COMBINE-lab/alevin-fry>`_       | RAD                     | MATRIX |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
+  | simpleaf      | Self-contained single-cell quantification wrapper (index + map + quant) around salmon/alevin-fry.                                                                                                   | simpleaf   | simpleaf      | `simpleaf <https://github.com/COMBINE-lab/simpleaf>`_           | FASTQ/TRIMMED_FASTQ     | MATRIX |
+  +---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+---------------+-----------------------------------------------------------------+-------------------------+--------+
 
 
 Differential Analyses
@@ -230,32 +230,50 @@ Includes DE, DEU, DAS and DTU
 .. table:: 
   :class: tight-table
 
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | Tool      | Analysis                            | Filtering        | Normalization   | Distribution   | Testing                         | Significance   | Results Table                                        | further                                 | SigTables                               | Clustering        | further                                                           | Rmd   |
-  +===========+=====================================+==================+=================+================+=================================+================+======================================================+=========================================+=========================================+===================+===================================================================+=======+
-  | edgeR     | Differential Gene Expression        | filterByExpr()   | TMM             | NB             | Fisher’s exact test             | pValue, LFC    | results, sorted-results                              | normalized                              | Sig, SigUP, SigDOWN                     | MDS-plot          | BCV, QLDisp, MD(per comparison)                                   | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | edgeR     | Differential Exon Usage             | filterByExpr()   | TMM             | NB             | Fisher’s exact test             | pValue, LFC    | results                                              | normalized                              |                                         | MDS-plot          | BCV, QLDisp, MD(per comparison)                                   | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | edgeR     | Differential Alternative Splicing   | filterByExpr()   | TMM             | NB             | Simes, gene-level, exon-level   | pValue, LFC    | results(diffSpliceExonTest, Simes-Test, Gene-Test)   |                                         | Sig, SigUP, SigDOWN                     | MDS-plot          | BCV, QLDisp, MD(per comparison), topSpliceSimes-plots(per Gene)   | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | DESeq2    | Differential Gene Expression        | RowSums >= 10    | RLE             | NB             | Wald test                       | pValue, LFC    | results                                              | rld, vsd, results(per comparison)       | Sig, SigUP, SigDOWN                     | PCA               | Heatmaps, MA(per comparison), VST-and-log2                        | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | DEXSeq    | Differential Exon Usage             | RowSums >= 10    | RLE             | Cox-Reid       | likelihood ratio test           |                |                                                      |                                         |                                         |                   |                                                                   |       |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | DEXSeq    | Differential Transcript Usage       | dmFilter()       | RLE             | Cox-Reid       | likelihood ratio test           | pValue         | results                                              |                                         |                                         |                   |                                                                   | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-  | DIEGO     | Differential Alternative Splicing   |                  |                 |                | Mann-Whitney U test             | pValue         | results                                              |                                         | Sig                                     | Dendrogram-plot   |                                                                   | ✓     |
-  +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-   | DRIMSeq   | Differential Transcript Usage       | dmFilter()       |                 | DM             |                                 | pValue, LFC    | results(transcript, genes)                           | Proportions-table, genewise precision   | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | FeatPerGene, precision, Pvalues (per comparison)                  | ✓     |
-   +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
-   | SPIT      | Differential Transcript Usage       | IF-dominance     |                 | KDE            | Mann-Whitney U                  | pValue, LFC    | results(transcript, genes, ifs)                      | IF-table                                | Sig, SigUP, SigDOWN (transcipt, gene)   |                   | PValues, Wasserstein (per comparison)                             | ✓     |
-    +-----------+-------------------------------------+------------------+-----------------+----------------+---------------------------------+----------------+------------------------------------------------------+-----------------------------------------+-----------------------------------------+-------------------+-------------------------------------------------------------------+-------+
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | Tool    | Analysis                          | Filtering      | Normalization | Distribution | Testing                       | Significance | Results Table                                      | further                               | SigTables                             | Clustering      | further                                                         | Rmd |
+  +=========+===================================+================+===============+==============+===============================+==============+====================================================+=======================================+=======================================+=================+=================================================================+=====+
+  | edgeR   | Differential Gene Expression      | filterByExpr() | TMM           | NB           | Fisher’s exact test           | pValue, LFC  | results, sorted-results                            | normalized                            | Sig, SigUP, SigDOWN                   | MDS-plot        | BCV, QLDisp, MD(per comparison)                                 | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | edgeR   | Differential Exon Usage           | filterByExpr() | TMM           | NB           | Fisher’s exact test           | pValue, LFC  | results                                            | normalized                            |                                       | MDS-plot        | BCV, QLDisp, MD(per comparison)                                 | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | edgeR   | Differential Alternative Splicing | filterByExpr() | TMM           | NB           | Simes, gene-level, exon-level | pValue, LFC  | results(diffSpliceExonTest, Simes-Test, Gene-Test) |                                       | Sig, SigUP, SigDOWN                   | MDS-plot        | BCV, QLDisp, MD(per comparison), topSpliceSimes-plots(per Gene) | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | DESeq2  | Differential Gene Expression      | RowSums >= 10  | RLE           | NB           | Wald test                     | pValue, LFC  | results                                            | rld, vsd, results(per comparison)     | Sig, SigUP, SigDOWN                   | PCA             | Heatmaps, MA(per comparison), VST-and-log2                      | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | DEXSeq  | Differential Exon Usage           | RowSums >= 10  | RLE           | Cox-Reid     | likelihood ratio test         |              |                                                    |                                       |                                       |                 |                                                                 |     |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | DEXSeq  | Differential Transcript Usage     | dmFilter()     | RLE           | Cox-Reid     | likelihood ratio test         | pValue       | results                                            |                                       |                                       |                 |                                                                 | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | DIEGO   | Differential Alternative Splicing |                |               |              | Mann-Whitney U test           | pValue       | results                                            |                                       | Sig                                   | Dendrogram-plot |                                                                 | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | DRIMSeq | Differential Transcript Usage     | dmFilter()     |               | DM           |                               | pValue, LFC  | results(transcript, genes)                         | Proportions-table, genewise precision | Sig, SigUP, SigDOWN (transcipt, gene) |                 | FeatPerGene, precision, Pvalues (per comparison)                | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
+  | SPIT    | Differential Transcript Usage     | IF-dominance   |               | KDE          | Mann-Whitney U                | pValue, LFC  | results(transcript, genes, ifs)                    | IF-table                              | Sig, SigUP, SigDOWN (transcipt, gene) |                 | PValues, Wasserstein (per comparison)                           | ✓   |
+  +---------+-----------------------------------+----------------+---------------+--------------+-------------------------------+--------------+----------------------------------------------------+---------------------------------------+---------------------------------------+-----------------+-----------------------------------------------------------------+-----+
 
 .. note::
 
   For DTU analyses, transcripts can optionally be pre-grouped with `terminus <https://github.com/COMBINE-lab/terminus>`_ to collapse transcripts that cannot be confidently distinguished. This is disabled by default and enabled per DTU tool via the ``TERMINUS`` option.
 
+PostDE (GO/GSEA/GSVA/decoupleR/dream)
+#####################################
+
+PostDE runs enrichment and regulatory analysis on the results of a DE analysis (DESeq2/edgeR only; DEU/DTU/DAS are not supported). It is configured via the top-level ``POSTDE`` section of the config file, see :ref:`config-file` for the analysis JSON schema and examples.
+
+Outputs are written under ``POSTDE/<combo>/`` for each DE tool combo:
+
+* ``manifest.json`` — machine-readable summary of all PostDE outputs.
+* ``report_data.rds`` — the full R report data (config, bundle and outputs) for downstream reporting.
+* one subdirectory per contrast with the per-contrast result TSVs (enrichment tables, GSVA scores/differential, decoupler activities/differential, dream results).
+
+GSEA consumes the **full ranked gene list** from the DE analysis — it is never restricted to the significant tables. ORA (gProfiler/clusterProfiler enricher) uses the significant genes defined by the PostDE ``padj``/``lfc`` cutoffs, which are independent of the ``DE.CUTOFFS``; a custom ``background`` file (one gene ID per row, no header) is supported and tested for ORA.
+
+GSVA runs per contrast on the cohort and design of that contrast, using the expression matrix captured by the DE analysis (optionally spike-in adjusted when the DE run used spike-in normalization). dream runs on the raw counts with the provided metadata/formula (no condition column in the metadata; the condition comes from the DE analysis). Online gProfiler runs require network consent (``allow_network=true``); the saved queries and provenance are stored alongside the results.
+
+HTML reporting (``plots``/``report``/``shiny``) is not implemented yet — enabling those keys is rejected at validation time.
+
+
 TRACKS
 ###############
 
@@ -331,9 +349,9 @@ is resource intensive, so the bundled cluster profile sets a long runtime for th
   :widths: 10, 40, 10, 10, 10, 10, 10
   :class: tight-table
 
-  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+----------------------------------------------------------------+-------------------------------+---------+
-  | TOOL        | DESCRIPTION                                                                                                                                                                             | ENV        | BIN         | LINK                                                           | INPUT                         | OUTPUT  |
-  +=============+=========================================================================================================================================================================================+============+=============+================================================================+===============================+=========+
-  | STAR-Fusion | STAR-Fusion identifies candidate fusion transcripts from the chimeric alignments produced by the STAR aligner using a CTAT genome resource library.                                      | starfusion | STAR-Fusion | `starfusion <https://github.com/STAR-Fusion/STAR-Fusion/wiki>`_ | Chimeric.out.junction / FASTQ | TSV     |
-  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+----------------------------------------------------------------+-------------------------------+---------+
+  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-----------------------------------------------------------------+-------------------------------+--------+
+  | TOOL        | DESCRIPTION                                                                                                                                         | ENV        | BIN         | LINK                                                            | INPUT                         | OUTPUT |
+  +=============+=====================================================================================================================================================+============+=============+=================================================================+===============================+========+
+  | STAR-Fusion | STAR-Fusion identifies candidate fusion transcripts from the chimeric alignments produced by the STAR aligner using a CTAT genome resource library. | starfusion | STAR-Fusion | `starfusion <https://github.com/STAR-Fusion/STAR-Fusion/wiki>`_ | Chimeric.out.junction / FASTQ | TSV    |
+  +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+------------+-------------+-----------------------------------------------------------------+-------------------------------+--------+
 
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
index 1c175928..c48d5033 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -45,7 +45,7 @@ params.gDTUCOMP = get_always('DTUCOMP') ?: ''
 params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
 params.gPVAL = get_always('DTUPVAL') ?: ''
 params.gLFC = get_always('DTULFC') ?: ''
-params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gPCOMBO = get_always('COMBO') ?: 'none'
 params.gCOUNTBIN = 'salmon'
 params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
index 7b1a24d8..7d0ab619 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -45,7 +45,7 @@ params.gDTUCOMP = get_always('DTUCOMP') ?: ''
 params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
 params.gPVAL = get_always('DTUPVAL') ?: ''
 params.gLFC = get_always('DTULFC') ?: ''
-params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gPCOMBO = get_always('COMBO') ?: 'none'
 params.gCOUNTBIN = 'salmon'
 params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
index accc5bdb..ed36b560 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -45,7 +45,7 @@ params.gDTUCOMP = get_always('DTUCOMP') ?: ''
 params.gDTUCOMPS = get_always('DTUCOMPS') ?: ''
 params.gPVAL = get_always('DTUPVAL') ?: ''
 params.gLFC = get_always('DTULFC') ?: ''
-params.gPCOMBO = get_always('params.gCOMBO') ?: 'none'
+params.gPCOMBO = get_always('COMBO') ?: 'none'
 params.gCOUNTBIN = 'salmon'
 params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
diff --git a/tests/test_Workflows.py b/tests/test_Workflows.py
index 53a8b018..5c85ea45 100644
--- a/tests/test_Workflows.py
+++ b/tests/test_Workflows.py
@@ -138,6 +138,81 @@ def test_multi_tool_product(self):
         assert all(n >= 1 for n in counts.values())
 
 
+class TestNfRwGetAlways:
+    """Literal get_always('KEY')/get_always(\"KEY\") lookups must survive
+    _nf_rw byte-exact; only dynamic get_always(KEY) and GString arguments
+    are rewritten."""
+
+    def test_plain_literal_protected(self):
+        text = "PCOMBO = get_always('COMBO') ?: 'none'"
+        assert mw._nf_rw(text, {"COMBO"}, set()) == text
+
+    def test_double_quoted_literal_protected(self):
+        text = 'PCOMBO = get_always("COMBO") ?: "none"'
+        assert mw._nf_rw(text, {"COMBO"}, set()) == text
+
+    def test_whitespace_and_escaping_preserved(self):
+        text = "X = get_always( 'KEY\\'S' )"
+        assert mw._nf_rw(text, {"KEY"}, set()) == text
+
+    def test_surrounding_bare_and_interpolation_rewritten(self):
+        text = "X = COMBO + get_always('COMBO') + $COMBO"
+        assert mw._nf_rw(text, {"COMBO"}, set()) == (
+            "X = params.gCOMBO + get_always('COMBO') + ${params.gCOMBO}"
+        )
+
+    def test_dynamic_args_rewritten(self):
+        assert mw._nf_rw("Y = get_always(COMBO)", {"COMBO"}, set()) == (
+            "Y = get_always(params.gCOMBO)"
+        )
+
+    def test_gstring_arg_rewritten(self):
+        assert mw._nf_rw('Z = get_always("$COMBO")', {"COMBO"}, set()) == (
+            'Z = get_always("${params.gCOMBO}")'
+        )
+
+    def test_template_literal_keys_preserved(self):
+        """Every literal get_always lookup in a workflow template must stay
+        byte-exact even when its key is itself a rewritten global name (the
+        key/global intersection that broke PCOMBO)."""
+        calls = set()
+        for path in (REPO / "workflows").glob("*.nf"):
+            for m in mw._GA_LITERAL.finditer(path.read_text()):
+                if m.group(1) == '"' and "$" in m.group(2):
+                    continue
+                calls.add((path.name, m.group(0), m.group(2)))
+        assert calls
+        for name, call, key in calls:
+            assert mw._nf_rw(call, {key}, set()) == call, (
+                f"{name}: literal lookup {call!r} rewritten"
+            )
+
+
+def test_nf_make_workflow_pcombo_preserves_key(workdir):
+    """The full header+template generation must keep the literal
+    get_always('COMBO') lookup in PCOMBO byte-exact instead of rewriting
+    the key to params.gCOMBO."""
+    cfg = _load("config_DTU_test.json")
+    conditions = mp.get_conditions(cfg)
+    _pre, sub, _post = mw.get_processes(cfg)
+    combos = mw.get_combo(sub, cfg, conditions)
+    samples = mp.get_samples_postprocess(cfg, "DTU")
+    subdir = "SubPostFlows"
+    mp.create_skeleton(subdir, None)
+    mw.nf_make_post(
+        "DTU", cfg, samples, conditions, subdir, "INFO", combinations=combos
+    )
+    produced = sorted(
+        os.path.relpath(p, workdir)
+        for p in glob.glob(os.path.join(subdir, "*_subflow.nf"))
+    )
+    assert produced, "generator produced no subflows"
+    for rel in produced:
+        text = Path(workdir / rel).read_text()
+        assert "params.gPCOMBO = get_always('COMBO') ?: 'none'" in text, rel
+        assert "get_always('params.gCOMBO')" not in text, rel
+
+
 # --------------------------------------------------------------------------- #
 # Golden-file / snapshot tests: file-emitting generators
 # --------------------------------------------------------------------------- #
diff --git a/tests/test_postde_configurator.py b/tests/test_postde_configurator.py
new file mode 100644
index 00000000..247d02fa
--- /dev/null
+++ b/tests/test_postde_configurator.py
@@ -0,0 +1,365 @@
+"""Focused tests for the PostDE slice of the web configurator and the CLI.
+
+Covers the web configurator (preview/save/create validation, disabled
+backwards compatibility, served HTML, serialized config reload) and the CLI
+``configure_postde`` function (choices and DE-tool exclusion). Uses tmp_path
+only, no local hardcoded paths.
+"""
+
+import importlib
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("snakemake")
+
+REPO = Path(__file__).resolve().parents[1]
+EXAMPLE = REPO / "configs" / "postde_analysis.json"
+TEMPLATE = REPO / "configs" / "template_base_commented.json"
+
+# --- web configurator ------------------------------------------------------
+
+try:
+    from fastapi.testclient import TestClient
+
+    from MONSDA import web_configurator as wc
+    from MONSDA.PostDE import load_postde_config
+
+    HAS_HTTPX = True
+except ImportError:  # pragma: no cover - fallback for envs without httpx
+    HAS_HTTPX = False
+    from MONSDA import web_configurator as wc
+    from MONSDA.PostDE import load_postde_config
+
+
+def _settings():
+    return {"Exp": {"WT": {"SAMPLES": ["s1", "s2"], "GROUPS": ["g", "g"]}}}
+
+
+def _preview_body(workflows=("DE",), postde=None, tools=None):
+    body = {
+        "config_name": "t",
+        "output_dir": str(REPO),
+        "workflows": list(workflows),
+        "tools": tools or {},
+        "maxthreads": "16",
+        "settings": _settings(),
+        "samplesheet_path": None,
+    }
+    if postde is not None:
+        body["postde"] = postde
+    return body
+
+
+def _enabled_postde():
+    return {"enabled": True, "config": str(EXAMPLE)}
+
+
+def _client():
+    return TestClient(wc.app)
+
+
+@pytest.mark.skipif(not HAS_HTTPX, reason="httpx not available")
+class TestWebPreview:
+    def test_preview_attaches_disabled_postde(self):
+        r = _client().post("/config/preview", json=_preview_body())
+        assert r.status_code == 200
+        assert r.json()["config"]["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_preview_enabled_postde_validates(self):
+        r = _client().post(
+            "/config/preview", json=_preview_body(postde=_enabled_postde())
+        )
+        assert r.status_code == 200
+        section = r.json()["config"]["POSTDE"]
+        assert section["enabled"] is True
+        assert section["config"] == str(EXAMPLE.resolve())
+
+    def test_preview_disabled_postde_backwards_compat(self):
+        r = _client().post(
+            "/config/preview",
+            json=_preview_body(postde={"enabled": False, "config": ""}),
+        )
+        assert r.status_code == 200
+        assert r.json()["config"]["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_preview_missing_de_raises(self):
+        r = _client().post(
+            "/config/preview",
+            json=_preview_body(workflows=("QC",), postde=_enabled_postde()),
+        )
+        assert r.status_code == 400
+        assert "DE in WORKFLOWS" in r.json()["detail"]
+
+    def test_preview_invalid_postde_section_raises(self):
+        r = _client().post(
+            "/config/preview",
+            json=_preview_body(postde={"enabled": "yes", "config": ""}),
+        )
+        assert r.status_code == 400
+
+
+@pytest.mark.skipif(not HAS_HTTPX, reason="httpx not available")
+class TestWebSaveCreate:
+    def _valid_cfg(self, tmp_path):
+        return wc.build_config(
+            wc.BuildConfigRequest(
+                config_name="t",
+                output_dir=str(tmp_path),
+                workflows=["DE"],
+                settings=_settings(),
+                postde=_enabled_postde(),
+            )
+        )
+
+    def test_save_validates_postde_before_write(self, tmp_path):
+        cfg = self._valid_cfg(tmp_path)
+        cfg["POSTDE"] = {"enabled": True, "config": "missing.json"}
+        r = _client().post(
+            "/config/save",
+            json={
+                "config_name": "t",
+                "output_dir": str(tmp_path),
+                "config": cfg,
+            },
+        )
+        assert r.status_code == 400
+        assert not list(tmp_path.glob("config_*.json"))
+
+    def test_save_unsupported_de_tool_raises(self, tmp_path):
+        cfg = self._valid_cfg(tmp_path)
+        cfg["DE"]["TOOLS"] = {"diego": "Analysis/DE/DIEGO.R"}
+        r = _client().post(
+            "/config/save",
+            json={
+                "config_name": "t",
+                "output_dir": str(tmp_path),
+                "config": cfg,
+            },
+        )
+        assert r.status_code == 400
+        assert "does not support" in r.json()["detail"]
+
+    def test_save_writes_normalized_postde(self, tmp_path):
+        cfg = self._valid_cfg(tmp_path)
+        r = _client().post(
+            "/config/save",
+            json={
+                "config_name": "t",
+                "output_dir": str(tmp_path),
+                "config": cfg,
+            },
+        )
+        assert r.status_code == 200
+        written = json.loads((tmp_path / "config_t.json").read_text())
+        assert written["POSTDE"]["enabled"] is True
+        assert written["POSTDE"]["config"] == str(EXAMPLE.resolve())
+
+    def test_create_validates_postde_before_creation(self, tmp_path):
+        cfg = self._valid_cfg(tmp_path)
+        cfg["POSTDE"] = {"enabled": True, "config": "missing.json"}
+        r = _client().post(
+            "/project/create",
+            json={
+                "project_dir": str(tmp_path),
+                "project_name": "proj",
+                "condition_files": [],
+                "config": cfg,
+                "settings": _settings(),
+            },
+        )
+        assert r.status_code == 400
+        assert not (tmp_path / "proj").exists()
+
+    def test_create_unsupported_de_tool_raises(self, tmp_path):
+        cfg = self._valid_cfg(tmp_path)
+        cfg["DE"]["TOOLS"] = {"diego": "Analysis/DE/DIEGO.R"}
+        r = _client().post(
+            "/project/create",
+            json={
+                "project_dir": str(tmp_path),
+                "project_name": "proj",
+                "condition_files": [],
+                "config": cfg,
+                "settings": _settings(),
+            },
+        )
+        assert r.status_code == 400
+        assert not (tmp_path / "proj").exists()
+
+    def test_serialized_config_reloads(self, tmp_path):
+        cfg = wc.build_config(
+            wc.BuildConfigRequest(
+                config_name="t",
+                output_dir=str(tmp_path),
+                workflows=["DE"],
+                settings=_settings(),
+                postde=_enabled_postde(),
+            )
+        )
+        path = tmp_path / "config_t.json"
+        path.write_text(json.dumps(cfg))
+        reloaded = json.loads(path.read_text())
+        section = load_postde_config(reloaded["POSTDE"], config=reloaded)
+        assert section["enabled"] is True
+        assert section["config"] == str(EXAMPLE.resolve())
+
+
+@pytest.mark.skipif(not HAS_HTTPX, reason="httpx not available")
+class TestWebHtml:
+    def test_served_html_has_postde_controls(self):
+        html = _client().get("/").text
+        assert "postdeEnabled" in html
+        assert "postdeConfig" in html
+        assert "openPathBrowser('postdeConfig','all')" in html
+
+    def test_served_html_does_not_offer_postde_as_workflow(self):
+        html = _client().get("/").text
+        # the frontend workflow filter must exclude POSTDE from the chooser
+        assert "'POSTDE'" in html
+        assert "data-workflow=\"POSTDE\"" not in html
+
+
+class TestTemplateAndExample:
+    def test_template_has_disabled_postde(self):
+        template = wc.strip_comments(wc.load_template())
+        assert template["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_example_validates_from_arbitrary_cwd(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        section = load_postde_config({"enabled": True, "config": str(EXAMPLE)})
+        assert section["enabled"] is True
+        assert section["config"] == str(EXAMPLE.resolve())
+
+    def test_example_requires_no_external_resources(self):
+        analysis = json.loads(EXAMPLE.read_text())
+        for method, keys in (
+            ("gprofiler", ("background",)),
+            ("clusterprofiler", ("term2gene", "term2name", "background")),
+            ("decoupler", ("network",)),
+            ("dream", ("metadata",)),
+        ):
+            for key in keys:
+                assert analysis[method].get(key) in (None, ""), (
+                    method + "." + key + " must not require a resource file"
+                )
+
+
+# --- CLI configurator ------------------------------------------------------
+
+import snakemake.common.configfile as configfile  # noqa: E402
+
+_ORIGINAL_LOAD_CONFIGFILE = configfile.load_configfile
+
+
+def _load_repo_template(_):
+    return _ORIGINAL_LOAD_CONFIGFILE(str(TEMPLATE))
+
+
+configfile.load_configfile = _load_repo_template
+_original_argv = sys.argv
+sys.argv = [sys.argv[0]]
+configurator = importlib.import_module("MONSDA.Configurator")
+sys.argv = _original_argv
+configfile.load_configfile = _ORIGINAL_LOAD_CONFIGFILE
+# the import-time monkeypatch above bound Configurator's load_configfile to the
+# template loader; restore it so modify() reads real config files
+configurator.load_configfile = _ORIGINAL_LOAD_CONFIGFILE
+
+
+def _stub_guide(monkeypatch, answers):
+    project = configurator.PROJECT()
+    guide = configurator.GUIDE()
+    monkeypatch.setattr(configurator, "project", project, raising=False)
+    monkeypatch.setattr(configurator, "guide", guide, raising=False)
+    monkeypatch.setattr(configurator, "pickle_unfinished", lambda _: None)
+    it = iter(answers)
+
+    def fake_display(options=None, question=None, proof=None, spec=None, whitespace=False):
+        configurator.guide.answer = next(it)
+
+    monkeypatch.setattr(configurator.guide, "display", fake_display)
+    monkeypatch.setattr(configurator.guide, "clear", lambda *_: None)
+    return project, guide
+
+
+class TestCliConfigurePostde:
+    def test_no_de_outputs_disabled(self, monkeypatch):
+        project, _ = _stub_guide(monkeypatch, [])
+        project.workflowsDict["QC"]
+        final_dict = {"WORKFLOWS": "QC"}
+        configurator.configure_postde(final_dict)
+        assert final_dict["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_choice_no_disables(self, monkeypatch):
+        project, _ = _stub_guide(monkeypatch, ["no"])
+        project.workflowsDict["DE"]
+        final_dict = {"WORKFLOWS": "DE"}
+        configurator.configure_postde(final_dict)
+        assert final_dict["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_choice_yes_enables_with_abs_path(self, monkeypatch):
+        project, _ = _stub_guide(monkeypatch, ["yes", str(EXAMPLE)])
+        project.workflowsDict["DE"]
+        final_dict = {"WORKFLOWS": "DE"}
+        configurator.configure_postde(final_dict)
+        assert final_dict["POSTDE"]["enabled"] is True
+        assert final_dict["POSTDE"]["config"] == str(EXAMPLE.resolve())
+
+    def test_invalid_path_retries(self, monkeypatch):
+        project, _ = _stub_guide(monkeypatch, ["yes", "missing.json", str(EXAMPLE)])
+        project.workflowsDict["DE"]
+        final_dict = {"WORKFLOWS": "DE"}
+        configurator.configure_postde(final_dict)
+        assert final_dict["POSTDE"]["enabled"] is True
+
+    def test_unsupported_de_tool_rejected(self, monkeypatch, capsys):
+        project, _ = _stub_guide(monkeypatch, ["yes", str(EXAMPLE)])
+        project.workflowsDict["DE"]
+        final_dict = {
+            "WORKFLOWS": "DE",
+            "DE": {"TOOLS": {"diego": "Analysis/DE/DIEGO.R"}},
+        }
+        # the error is reported and the path prompt is retried
+        with pytest.raises(StopIteration):
+            configurator.configure_postde(final_dict)
+        assert "does not support DE tools" in capsys.readouterr().out
+
+    def test_old_pickled_project_without_postde_attr(self, monkeypatch):
+        project, _ = _stub_guide(monkeypatch, ["no"])
+        project.workflowsDict["DE"]
+        del project.postde  # simulate a pickled project from before PostDE
+        final_dict = {"WORKFLOWS": "DE"}
+        configurator.configure_postde(final_dict)
+        assert final_dict["POSTDE"] == {"enabled": False, "config": ""}
+
+    def test_modify_old_config_without_postde_key(self, tmp_path, monkeypatch):
+        cfg_path = tmp_path / "config_old.json"
+        cfg_path.write_text(
+            json.dumps(
+                {
+                    "WORKFLOWS": "DE",
+                    "MAXTHREADS": "8",
+                    "VERSION": "x",
+                    "BINS": "MONSDA/scripts",
+                    "SETTINGS": {
+                        "Exp": {"WT": {"SAMPLES": ["s1"], "GROUPS": ["g"]}}
+                    },
+                    "DE": {"TOOLS": {"deseq2": "Analysis/DE/DESEQ2.R"}},
+                }
+            )
+        )
+        project, _ = _stub_guide(monkeypatch, ["5", "no", ""])
+        project.mode = "modify"
+        captured = {}
+
+        def fake_create_project(final_dict):
+            captured["final_dict"] = final_dict
+
+        monkeypatch.setattr(configurator, "create_project", fake_create_project)
+        configurator.modify(str(cfg_path))
+        assert captured["final_dict"]["POSTDE"] == {"enabled": False, "config": ""}
+        assert "DE" in captured["final_dict"]["WORKFLOWS"]
diff --git a/tests/test_postde_workflows.py b/tests/test_postde_workflows.py
index 819829a3..bde7c118 100644
--- a/tests/test_postde_workflows.py
+++ b/tests/test_postde_workflows.py
@@ -1,12 +1,11 @@
+import hashlib
 import json
 import os
 import re
-import shlex
 import shutil
-import string
 import subprocess
 import sys
-import types
+import textwrap
 from pathlib import Path
 
 import pytest
@@ -89,19 +88,23 @@ def _generate_de(engine, workdir, cfg):
     return subdir
 
 
-def _extract_nf_script(subflow, process_name):
+def _extract_nf_process(subflow, process_name):
     match = re.search(r"process\s+" + process_name + r"\s*\{", subflow)
     assert match, f"process {process_name} not found in generated subflow"
-    start = match.end()
+    start = match.start()
     depth = 1
-    i = start
+    i = match.end()
     while i < len(subflow) and depth > 0:
         if subflow[i] == "{":
             depth += 1
         elif subflow[i] == "}":
             depth -= 1
         i += 1
-    body = subflow[start:i]
+    return subflow[start:i]
+
+
+def _extract_nf_script(subflow, process_name):
+    body = _extract_nf_process(subflow, process_name)
     block = re.search(r'script:\s*"""\n(.*?)\n\s*"""', body, re.S)
     assert block, f"script block not found in process {process_name}"
     return block.group(1)
@@ -164,38 +167,95 @@ def _write_real_bundle(rscript, outdir, engine):
 def _extract_smk_rule_body(smk, rule_name):
     match = re.search(r"^\s*rule\s+" + rule_name + r"\s*:\s*$", smk, re.M)
     assert match, f"rule {rule_name} not found in generated snakefile"
-    rest = smk[match.end():]
     body = []
-    for ln in rest.split("\n"):
-        if body and re.match(
-            r"^\s*(rule|if|include|configfile|import|from|onsuccess|onerror)\b", ln
-        ):
+    for ln in smk[match.start():].split("\n"):
+        if body and not ln.strip():
+            continue
+        if body and not ln[0].isspace():
             break
         body.append(ln)
     return "\n".join(body)
 
 
-def _smk_params_shell(body):
-    params_m = re.search(r"params:\s*(.*?)(?=\n\s*shell:)", body, re.S)
-    assert params_m, "params block not found in rule body"
-    shell_m = re.search(r'shell:\s*"(.*?)"', body, re.S)
-    assert shell_m, "shell block not found in rule body"
-    lines = params_m.group(1).split("\n")
-    code = "\n".join(
-        [lines[0].strip().rstrip(",")]
-        + [ln.strip().rstrip(",") for ln in lines[1:] if ln.strip()]
+def _write_smk_launcher(launch, smk_text, detool, bundle_path, staged, combo):
+    body = textwrap.dedent(_extract_smk_rule_body(smk_text, "postde"))
+    stub = (
+        "import os\n"
+        f"BINS = {str(REPO / 'scripts')!r}\n"
+        f"combo = {combo!r}\n"
+        f"postde_inputs = {str(staged)!r}\n"
+        "postde_enabled = True\n"
+        "\n"
+        f"rule run_{detool}:\n"
+        "    output:\n"
+        f"        bundle = [{str(bundle_path)!r}]\n"
+        "\n"
     )
-    return code, shell_m.group(1)
+    (launch / "Snakefile").write_text(stub + body)
+
+
+def _write_nf_launcher(launch, subflow_text, bundle_path, staged, combo):
+    process = _extract_nf_process(subflow_text, "postde")
+    wrapper = (
+        "nextflow.enable.dsl=2\n"
+        "params.gTHREADS = 1\n"
+        f"params.gBINS = {str(REPO / 'scripts')!r}\n"
+        f"params.gSCOMBO = {combo!r}\n"
+        "\n"
+        + process
+        + "\n"
+        "workflow {\n"
+        f"    postde(Channel.value(file({str(bundle_path)!r})), Channel.value(file({str(staged)!r})))\n"
+        "}\n"
+    )
+    (launch / "main.nf").write_text(wrapper)
+
 
+def _check_manifest(outdir, bundle_path, config_path):
+    manifest = json.loads((outdir / "manifest.json").read_text())
+    assert manifest["output"] == "."
+    assert manifest["bundle_checksum"] == hashlib.md5(
+        Path(bundle_path).read_bytes()
+    ).hexdigest()
+    assert manifest["config_checksum"] == hashlib.md5(
+        Path(config_path).read_bytes()
+    ).hexdigest()
+    entry = manifest["entries"]["A-VS-B"]
+    assert entry["id"] == "A-VS-B"
+    assert entry["dir"] == "A-VS-B"
+    decoupler = entry["analyses"]["regulatory"]["decoupler"]
+    for method in ("ulm", "mlm"):
+        for kind in ("activities", "differential"):
+            rel = decoupler[method][kind]
+            assert not os.path.isabs(rel), rel
+            assert (outdir / rel).exists(), rel
+    return manifest
 
-def _format_shell(template, **fields):
-    class _QFmt(string.Formatter):
-        def format_field(self, value, spec):
-            if spec == "q":
-                return shlex.quote(str(value))
-            return super().format_field(value, spec)
 
-    return _QFmt().format(template, **fields)
+POSTDE_R_PACKAGES = ("decoupleR", "limma", "jsonlite", "dplyr", "tidyr")
+
+
+@pytest.fixture
+def postde_r_packages(tmp_path):
+    rscript = shutil.which("Rscript")
+    if not rscript:
+        pytest.skip("Rscript not found on PATH")
+    probe = tmp_path / "probe_packages.R"
+    probe.write_text(
+        "pkgs <- c("
+        + ", ".join(repr(p) for p in POSTDE_R_PACKAGES)
+        + ")\n"
+        "missing <- pkgs[!vapply(pkgs, requireNamespace, logical(1), quietly = TRUE)]\n"
+        "if (length(missing) > 0) cat('MISSING:', paste(missing, collapse = ' '), '\\n')\n"
+    )
+    result = subprocess.run([rscript, str(probe)], capture_output=True, text=True)
+    if "MISSING:" in result.stdout:
+        missing = result.stdout.split("MISSING:", 1)[1].strip()
+        pytest.skip(
+            "R packages required for the postde decoupler run are not installed: "
+            + missing
+        )
+    return rscript
 
 
 class TestLoadPostdeConfig:
@@ -625,12 +685,12 @@ def test_gsva_and_global_minmax_defaults(self, tmp_path):
 class TestPostdeExecutable:
     @pytest.mark.parametrize("engine", ["smk", "nf"])
     @pytest.mark.parametrize("detool", ["deseq2", "edger"])
-    def test_postde_runs_real_run_r(self, workdir, tmp_path, engine, detool):
+    def test_postde_runs_real_run_r(
+        self, workdir, tmp_path, engine, detool, postde_r_packages
+    ):
         """Run the generated postde process/rule unmodified against the real
         run.R with an offline decoupleR ULM/MLM analysis on a tiny bundle."""
-        rscript = shutil.which("Rscript")
-        if not rscript:
-            pytest.skip("Rscript not found on PATH")
+        rscript = postde_r_packages
         resdir = tmp_path / "res dir"
         resdir.mkdir()
         (resdir / "network.tsv").write_text(
@@ -658,75 +718,58 @@ def test_postde_runs_real_run_r(self, workdir, tmp_path, engine, detool):
             open(workdir / subdir / f"allconditions_DE_{detool}_subconfig.json")
         )
         assert confo["POSTDE"]["enabled"] is True
-        staged = confo["POSTDE"]["inputs"]
+        staged = Path(confo["POSTDE"]["inputs"])
         launch = workdir / "launch dir"
         launch.mkdir()
-        bundle_src = _write_real_bundle(rscript, launch, detool)
-        if engine == "nf":
-            subflow = (
-                workdir / subdir / f"allconditions_DE_{detool}_subflow.nf"
+        bundle = _write_real_bundle(rscript, launch, detool)
+        combo = f"{detool}_DE"
+        if engine == "smk":
+            smk = (
+                workdir / subdir / f"allconditions_DE_{detool}_subsnake.smk"
             ).read_text()
-            script = _extract_nf_script(subflow, "postde")
-            script = script.replace("\\$", "$")
-            script = script.replace("${params.gBINS}", str(REPO / "scripts"))
-            shutil.copy2(bundle_src, launch / "bundle")
-            os.symlink(workdir / staged, launch / "postde_inputs")
+            _write_smk_launcher(launch, smk, detool, bundle, staged, combo)
             result = subprocess.run(
-                script, shell=True, cwd=str(launch), capture_output=True, text=True
+                [
+                    sys.executable,
+                    "-m",
+                    "snakemake",
+                    "-j1",
+                    "-s",
+                    str(launch / "Snakefile"),
+                    "POSTDE/" + combo,
+                ],
+                cwd=str(launch),
+                capture_output=True,
+                text=True,
+                env={**os.environ, "PYTHONPATH": str(REPO)},
             )
             assert result.returncode == 0, result.stderr[-2000:]
-            outdir = launch / "postde"
-            log = launch / "log"
         else:
-            smk = (
-                workdir / subdir / f"allconditions_DE_{detool}_subsnake.smk"
+            subflow = (
+                workdir / subdir / f"allconditions_DE_{detool}_subflow.nf"
             ).read_text()
-            body = _extract_smk_rule_body(smk, "postde")
-            params_code, shell_tpl = _smk_params_shell(body)
-            combo = f"{detool}_DE"
-            ns = {"os": os, "combo": combo}
-            exec(params_code, ns)
-            fake_input = {
-                "bundle": [str(bundle_src)],
-                "staged": str(workdir / staged),
-                "config": str(workdir / staged / "config.json"),
-                "script": str(REPO / "scripts" / "Analysis" / "PostDE" / "run.R"),
-                "common": str(REPO / "scripts" / "Analysis" / "PostDE" / "common.R"),
-                "enrichment": str(
-                    REPO / "scripts" / "Analysis" / "PostDE" / "enrichment.R"
-                ),
-                "regulatory": str(
-                    REPO / "scripts" / "Analysis" / "PostDE" / "regulatory.R"
-                ),
-            }
-            old = os.getcwd()
-            os.chdir(launch)
-            try:
-                params = {
-                    "bundle": ns["bundle"](
-                        None, types.SimpleNamespace(**fake_input)
-                    ),
-                    "outdir": ns["outdir"](None),
-                }
-                log = os.path.abspath(
-                    os.path.join("LOGS", combo, "DE", detool, "postde.log")
-                )
-            finally:
-                os.chdir(old)
-            shell = _format_shell(
-                shell_tpl,
-                input=types.SimpleNamespace(**fake_input),
-                params=types.SimpleNamespace(**params),
-                log=log,
-            )
+            _write_nf_launcher(launch, subflow, bundle, staged, combo)
             result = subprocess.run(
-                shell, shell=True, cwd=str(launch), capture_output=True, text=True
+                [
+                    "nextflow",
+                    "run",
+                    "-ansi-log",
+                    "false",
+                    str(launch / "main.nf"),
+                    "-work-dir",
+                    str(launch / "work"),
+                ],
+                cwd=str(launch),
+                capture_output=True,
+                text=True,
+                env={**os.environ, "NXF_HOME": str(launch / ".nextflow")},
+                timeout=600,
             )
             assert result.returncode == 0, result.stderr[-2000:]
-            outdir = launch / "POSTDE" / combo
-            log = launch / "LOGS" / combo / "DE" / detool / "postde.log"
+        outdir = launch / "POSTDE" / combo
         assert (outdir / "manifest.json").exists()
         assert (outdir / "report_data.rds").exists()
+        _check_manifest(outdir, bundle, staged / "config.json")
         entry = outdir / "A-VS-B"
         for name in (
             "decoupler_ulm_activities.tsv",
@@ -738,11 +781,22 @@ def test_postde_runs_real_run_r(self, workdir, tmp_path, engine, detool):
             "decoupler_contrast.tsv",
         ):
             assert (entry / name).exists(), name
+        for method in ("ulm", "mlm"):
+            diff = (
+                entry / f"decoupler_{method}_differential.tsv"
+            ).read_text().splitlines()
+            assert len(diff) >= 2, f"{method} differential has no data rows"
+            acts = (
+                entry / f"decoupler_{method}_activities.tsv"
+            ).read_text().splitlines()
+            assert len(acts) >= 2, f"{method} activities has no data rows"
+        log = launch / "LOGS" / combo / "DE" / detool / "postde.log"
         assert log.exists()
 
 
 class TestCliSave:
-    def test_cli_save_generates_postde(self, tmp_path):
+    @pytest.mark.parametrize("engine", ["smk", "nf"])
+    def test_cli_save_generates_postde(self, tmp_path, engine):
         for item in ("FASTQ", "GENOME"):
             os.symlink(DATA / item, tmp_path / item)
         (tmp_path / "sitecustomize.py").write_text(
@@ -763,15 +817,21 @@ def test_cli_save_generates_postde(self, tmp_path):
         }
         (tmp_path / "config_Test.json").write_text(json.dumps(cfg))
         env = {**os.environ, "PYTHONPATH": str(REPO) + os.pathsep + str(tmp_path)}
+        cmd = [
+            sys.executable,
+            "-m",
+            "MONSDA.RunMONSDA",
+            "--save",
+            "-c",
+            "config_Test.json",
+            "-d",
+            "tmp",
+            "-j2",
+        ]
+        if engine == "nf":
+            cmd.append("--nextflow")
         result = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "MONSDA.RunMONSDA",
-                "--save",
-                "-c",
-                "config_Test.json",
-            ],
+            cmd,
             cwd=str(tmp_path),
             env=env,
             capture_output=True,
@@ -779,10 +839,13 @@ def test_cli_save_generates_postde(self, tmp_path):
             timeout=300,
         )
         assert result.returncode == 0, result.stderr[-2000:]
-        subdir = tmp_path / "SubSnakes"
+        subdir = tmp_path / ("SubFlows" if engine == "nf" else "SubSnakes")
         confo = json.load(open(subdir / "allconditions_DE_deseq2_subconfig.json"))
         assert confo["POSTDE"]["enabled"] is True
         staged = confo["POSTDE"]["inputs"]
         assert (tmp_path / staged / "config.json").exists()
         commands = (tmp_path / "JOBS" / "MONSDA.commands").read_text()
-        assert "allconditions_DE_deseq2_subsnake.smk" in commands
+        if engine == "nf":
+            assert "allconditions_DE_deseq2_subflow.nf" in commands
+        else:
+            assert "allconditions_DE_deseq2_subsnake.smk" in commands
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 3581f439..75da884d 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -10,7 +10,7 @@ DECOMP = get_always('DECOMP') ?: ''
 DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
-PCOMBO = COMBO ?: 'none'
+PCOMBO = get_always('COMBO') ?: 'none'
 PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index cbcbb0ba..792bc2f9 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -24,7 +24,7 @@ rule themall:
             sig_d = expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             sig_u = expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison=compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_DESEQ2_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison=compstr, scombo=scombo),
             Rmd = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
-            postde = directory(expand("POSTDE/{combo}", combo=combo)) if postde_enabled else []
+            postde = expand("POSTDE/{combo}", combo=combo) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 7856ed90..0efa6536 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -11,7 +11,7 @@ DECOMP = get_always('DECOMP') ?: ''
 DECOMPS = get_always('DECOMPS') ?: ''
 PVAL = get_always('DEPVAL') ?: ''
 LFC = get_always('DELFC') ?: ''
-PCOMBO = COMBO ?: 'none'
+PCOMBO = get_always('COMBO') ?: 'none'
 PCOMBO_NORM = PCOMBO == 'none' ? '' : PCOMBO
 POSTDE_ENABLED = get_always('POSTDE_ENABLED') ?: false
 POSTDE_INPUTS = get_always('POSTDE_INPUTS') ?: ''
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index b1eb0bd4..b334ebb8 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -23,7 +23,7 @@ rule themall:
             sig_u   = expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigUP_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             sig_d   = expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results.tsv.gz", combo=combo, comparison = compstr, scombo=scombo) if not usespike else expand("DE/{combo}/Tables/SigDOWN_DE_EDGER_{scombo}_{comparison}_table_results_norm.tsv.gz", combo=combo, comparison = compstr, scombo=scombo),
             Rmd     = expand("REPORTS/SUMMARY/RmdSnippets/{combo}.Rmd", combo=combo),
-            postde = directory(expand("POSTDE/{combo}", combo=combo)) if postde_enabled else []
+            postde = expand("POSTDE/{combo}", combo=combo) if postde_enabled else []
 
 rule featurecount_unique:
     input:  reads = expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique.bam", scombo=scombo) if not usededup else expand("MAPPED/{scombo}/{{file}}_mapped_sorted_unique_dedup.bam", scombo=scombo)

From 23d2731da211d652e09ca7dfd5b3508fc133fd3d Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 20:03:08 +0200
Subject: [PATCH 66/80] ready to test on real data

---
 MONSDA/RunMONSDA.py                    |   6 +-
 docs/source/workflows.rst              |  26 +++
 scripts/Analysis/check_strandedness.py | 238 +++++++++++++++++++++++++
 tests/test_rustqc_strandedness.py      | 237 ++++++++++++++++++++++++
 workflows/rustqc.nf                    |   3 +-
 workflows/rustqc.smk                   |  10 +-
 6 files changed, 512 insertions(+), 8 deletions(-)
 create mode 100755 scripts/Analysis/check_strandedness.py
 create mode 100644 tests/test_rustqc_strandedness.py

diff --git a/MONSDA/RunMONSDA.py b/MONSDA/RunMONSDA.py
index b75c096f..f174db73 100755
--- a/MONSDA/RunMONSDA.py
+++ b/MONSDA/RunMONSDA.py
@@ -911,7 +911,7 @@ def runjob(jobtorun):
                         log.error(logid + "STOPPING: " + str(output))
                     log.info("PLEASE CHECK LOG AT LOGS/MONSDA.log")
                     job.kill()
-                    sys.exit()
+                    sys.exit(1)
                 else:
                     log.info(logid + str(output))
             if outerr and outerr != "":
@@ -926,7 +926,7 @@ def runjob(jobtorun):
                     log.error(logid + "STOPPING: " + str(outerr))
                     log.info("PLEASE CHECK LOG AT LOGS/MONSDA.log")
                     job.kill()
-                    sys.exit()
+                    sys.exit(1)
                 else:
                     log.info(logid + str(outerr))
             if job.poll() is not None:
@@ -956,7 +956,7 @@ def runjob(jobtorun):
             exc_tb,
         )
         log.error("".join(tbe.format()))
-        sys.exit()
+        sys.exit(1)
 
 
 def main():
diff --git a/docs/source/workflows.rst b/docs/source/workflows.rst
index 8c944367..2453561c 100644
--- a/docs/source/workflows.rst
+++ b/docs/source/workflows.rst
@@ -110,6 +110,32 @@ If any of the below listed processing steps is defined in the config.json, quali
   | RustQC (includes MULTIQC) | High-performance RNA-seq QC suite with MultiQC-compatible outputs. | rustqc | rustqc | `rustqc <https://github.com/seqeralabs/RustQC>`_                       | BAM       | TEXT/TSV/LOG |
   +---------------------------+--------------------------------------------------------------------+--------+--------+------------------------------------------------------------------------+-----------+--------------+
 
+RustQC runs on mapped BAM files and includes a strandedness guard: after the
+RustQC command finishes, the inferred strand assignment from its
+``infer_experiment`` report is compared against the ``SEQUENCING`` setting
+(``paired,fr``, ``paired,rf`` or ``single,fr``/``single,rf``) configured for
+the sample. A confident mismatch aborts the QC job with an error instead of
+silently accepting a conflicting configuration. No extra config switch is
+needed when RustQC is selected. ``fr`` means forward, ``rf`` means reverse,
+and omitting either strand suffix means unstranded.
+
+The check requires at least 50% of reads to have a strand assignment. Among
+assigned reads, at least 80% forward or reverse support identifies that strand;
+40--60% forward support identifies an unstranded library. Intermediate ratios
+or insufficient assignments produce a warning (``NOT validated``), not a
+mismatch. These are fraction-based heuristics, not a statistical confidence
+test or a minimum-read-count check. Missing or malformed inference reports
+fail the task rather than silently bypassing validation.
+
+The verdict is written to ``strandedness_check.json`` inside the RustQC output
+directory. On failure, Snakemake may remove failed outputs; the error remains
+in ``LOGS/<combo>/<sample>/QC/rustqc/``. Nextflow retains the error and verdict
+in the failed task's work directory. MONSDA exits nonzero and does not proceed
+to subsequent analysis workflows. Already-running independent tasks may have
+produced outputs before the QC failure is detected; this is not a pre-mapping
+check. Verify the library protocol and annotation, correct ``SEQUENCING`` if
+needed, and regenerate the workflows before resuming.
+
 
 Trimming
 ########
diff --git a/scripts/Analysis/check_strandedness.py b/scripts/Analysis/check_strandedness.py
new file mode 100755
index 00000000..1daec387
--- /dev/null
+++ b/scripts/Analysis/check_strandedness.py
@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""RustQC strandedness runtime guard.
+
+Compares the strand assignment inferred from a RustQC ``infer_experiment``
+report against the strand setting configured in MONSDA. Runs as a gate after
+the RustQC command inside the QC workflow: a confident mismatch aborts the
+job (exit 2) instead of silently producing mis-stranded QC output.
+
+Exit codes: 0 on match or when the data does not allow a confident verdict
+(inconclusive/ambiguous, reported as NOT validated), 2 on a clear mismatch or
+on malformed/missing input. A JSON report is written for every successfully
+parsed input when ``--report`` is given.
+"""
+
+import argparse
+import json
+import math
+import re
+import sys
+from pathlib import Path
+
+PAIRED_FORWARD = "1++,1--,2+-,2-+"
+PAIRED_REVERSE = "1+-,1-+,2++,2--"
+SINGLE_FORWARD = "++,--"
+SINGLE_REVERSE = "+-,-+"
+
+EXPECTED_ALIASES = {
+    "forward": "forward",
+    "reverse": "reverse",
+    "unstranded": "unstranded",
+    "fr": "forward",
+    "rf": "reverse",
+}
+
+THRESHOLDS = {
+    "assigned_min": 0.5,
+    "forward_ratio": 0.8,
+    "unstranded_low": 0.4,
+    "unstranded_high": 0.6,
+}
+
+SUM_TOL = 0.001
+
+
+class StrandednessError(Exception):
+    pass
+
+
+def norm_pattern(pattern):
+    return "".join(pattern.split())
+
+
+def find_infer_file(qc_dir):
+    matches = sorted(qc_dir.rglob("*.infer_experiment.txt"))
+    if not matches:
+        raise StrandednessError(
+            "no *.infer_experiment.txt found under %s" % qc_dir
+        )
+    if len(matches) > 1:
+        raise StrandednessError(
+            "multiple *.infer_experiment.txt found under %s: %s"
+            % (qc_dir, ", ".join(str(m) for m in matches))
+        )
+    return matches[0]
+
+
+def parse_infer_experiment(path):
+    mode = None
+    fields = {}
+    with open(path) as fh:
+        for lineno, line in enumerate(fh, 1):
+            line = line.strip()
+            if not line:
+                continue
+            head = re.match(r"This is (Pair|Single)End Data$", line)
+            if head:
+                if mode is not None:
+                    raise StrandednessError(
+                        "%s:%d: duplicate paired/single header" % (path, lineno)
+                    )
+                mode = "paired" if head.group(1) == "Pair" else "single"
+                continue
+            frac = re.match(
+                r'Fraction of reads (?:failed to determine|explained by "([^"]*)"):\s*(\S+)$',
+                line,
+            )
+            if not frac:
+                raise StrandednessError(
+                    "%s:%d: unrecognized line %r" % (path, lineno, line)
+                )
+            pattern, value = frac.group(1), frac.group(2)
+            key = "failed" if pattern is None else norm_pattern(pattern)
+            if key not in ("failed", PAIRED_FORWARD, PAIRED_REVERSE,
+                           SINGLE_FORWARD, SINGLE_REVERSE):
+                raise StrandednessError(
+                    "%s:%d: unknown strand pattern %r" % (path, lineno, key)
+                )
+            if key in fields:
+                raise StrandednessError(
+                    "%s:%d: duplicate field %r" % (path, lineno, key)
+                )
+            try:
+                number = float(value)
+            except ValueError:
+                raise StrandednessError(
+                    "%s:%d: non-numeric fraction %r" % (path, lineno, value)
+                )
+            if not math.isfinite(number) or not 0.0 <= number <= 1.0:
+                raise StrandednessError(
+                    "%s:%d: fraction %r out of [0,1]" % (path, lineno, value)
+                )
+            fields[key] = number
+    if mode is None:
+        raise StrandednessError(
+            "%s: no 'This is PairEnd/SingleEnd Data' line found" % path
+        )
+    if "failed" not in fields:
+        raise StrandednessError(
+            "%s: missing 'Fraction of reads failed to determine' line" % path
+        )
+    if mode == "paired":
+        if PAIRED_FORWARD not in fields or PAIRED_REVERSE not in fields:
+            raise StrandednessError(
+                "%s: paired data missing 1++/1-- pattern fractions" % path
+            )
+        forward = fields[PAIRED_FORWARD]
+        reverse = fields[PAIRED_REVERSE]
+        for key in (SINGLE_FORWARD, SINGLE_REVERSE):
+            if fields.get(key, 0.0) > 0.0:
+                raise StrandednessError(
+                    "%s: paired data contains nonzero single-end pattern %r"
+                    % (path, key)
+                )
+    else:
+        if SINGLE_FORWARD not in fields or SINGLE_REVERSE not in fields:
+            raise StrandednessError(
+                "%s: single-end data missing ++/-- pattern fractions" % path
+            )
+        forward = fields[SINGLE_FORWARD]
+        reverse = fields[SINGLE_REVERSE]
+        for key in (PAIRED_FORWARD, PAIRED_REVERSE):
+            if key in fields:
+                raise StrandednessError(
+                    "%s: single-end data contains paired pattern %r" % (path, key)
+                )
+    failed = fields["failed"]
+    total = failed + forward + reverse
+    if not (abs(total - 1.0) <= SUM_TOL or (failed == 0.0 and forward == 0.0 and reverse == 0.0)):
+        raise StrandednessError(
+            "%s: fractions do not sum to 1 (got %.4f)" % (path, total)
+        )
+    return mode, failed, forward, reverse
+
+
+def infer_strandedness(failed, forward, reverse):
+    assigned = forward + reverse
+    if assigned < THRESHOLDS["assigned_min"]:
+        return "inconclusive"
+    ratio = forward / assigned
+    if ratio >= THRESHOLDS["forward_ratio"]:
+        return "forward"
+    if reverse / assigned >= THRESHOLDS["forward_ratio"]:
+        return "reverse"
+    if THRESHOLDS["unstranded_low"] <= ratio <= THRESHOLDS["unstranded_high"]:
+        return "unstranded"
+    return "ambiguous"
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Check RustQC inferred strandedness against the configured setting"
+    )
+    parser.add_argument("--qc-dir", required=True, help="per-sample RustQC output directory")
+    parser.add_argument(
+        "--expected",
+        required=True,
+        choices=sorted(EXPECTED_ALIASES),
+        help="configured strandedness (forward/reverse/unstranded or fr/rf)",
+    )
+    parser.add_argument("--sample", required=True, help="sample name")
+    parser.add_argument("--report", help="optional JSON report path")
+    args = parser.parse_args(argv)
+
+    expected = EXPECTED_ALIASES[args.expected]
+    try:
+        infer_file = find_infer_file(Path(args.qc_dir))
+        mode, failed, forward, reverse = parse_infer_experiment(infer_file)
+    except StrandednessError as err:
+        print("ERROR: %s" % err, file=sys.stderr)
+        return 2
+
+    inferred = infer_strandedness(failed, forward, reverse)
+    if inferred == expected:
+        status = "match"
+    elif inferred in ("forward", "reverse", "unstranded"):
+        status = "mismatch"
+    else:
+        status = inferred
+
+    report = {
+        "sample": args.sample,
+        "expected": expected,
+        "inferred": inferred,
+        "status": status,
+        "paired": mode == "paired",
+        "fractions": {
+            "failed": failed,
+            "forward": forward,
+            "reverse": reverse,
+        },
+        "thresholds": dict(THRESHOLDS),
+    }
+    if args.report:
+        Path(args.report).write_text(json.dumps(report, indent=2) + "\n")
+
+    if status == "match":
+        return 0
+    if status == "mismatch":
+        print(
+            "ERROR: strandedness mismatch for sample %s: configured %s, inferred %s "
+            "(forward=%.4f, reverse=%.4f, failed=%.4f). Correct "
+            "SETTINGS...SEQUENCING (paired,fr/rf or single,fr/rf) and check "
+            "protocol/reference. Not auto-changing."
+            % (args.sample, expected, inferred, forward, reverse, failed),
+            file=sys.stderr,
+        )
+        return 2
+    print(
+        "WARNING: strandedness NOT validated for sample %s: expected %s, inferred %s "
+        "(forward=%.4f, reverse=%.4f, failed=%.4f)"
+        % (args.sample, expected, inferred, forward, reverse, failed),
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_rustqc_strandedness.py b/tests/test_rustqc_strandedness.py
new file mode 100644
index 00000000..582fe52d
--- /dev/null
+++ b/tests/test_rustqc_strandedness.py
@@ -0,0 +1,237 @@
+"""Strandedness CLI and executable workflow gates; no writes to shared fixtures."""
+import importlib.util
+import json
+import os
+from pathlib import Path
+import shlex
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+CHECKER = ROOT / 'scripts/Analysis/check_strandedness.py'
+spec = importlib.util.spec_from_file_location('check_strandedness', CHECKER)
+checker = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(checker)
+
+
+@pytest.fixture(autouse=True)
+def sandbox(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+
+def infer_text(paired=True, forward=.95, reverse=.03, failed=.02):
+    patterns = (checker.PAIRED_FORWARD, checker.PAIRED_REVERSE) if paired else (
+        checker.SINGLE_FORWARD, checker.SINGLE_REVERSE)
+    return (
+        f'This is {"Pair" if paired else "Single"}End Data\n'
+        f'Fraction of reads failed to determine: {failed:.4f}\n'
+        f'Fraction of reads explained by "{patterns[0]}": {forward:.4f}\n'
+        f'Fraction of reads explained by "{patterns[1]}": {reverse:.4f}\n'
+    )
+
+
+def run_checker(tmp_path, text, expected='forward', flat=False):
+    qc = tmp_path / 'QC sample'
+    folder = qc if flat else qc / 'rseqc/infer_experiment'
+    folder.mkdir(parents=True, exist_ok=True)
+    (folder / 'sample.infer_experiment.txt').write_text(text)
+    report = qc / 'strandedness_check.json'
+    result = subprocess.run(
+        [sys.executable, str(CHECKER), '--qc-dir', str(qc), '--expected', expected,
+         '--sample', 'sample name', '--report', str(report)],
+        capture_output=True, text=True, timeout=20)
+    return result, json.loads(report.read_text()) if report.exists() else None
+
+
+@pytest.mark.parametrize('paired', [True, False])
+@pytest.mark.parametrize('flat', [True, False])
+@pytest.mark.parametrize('inferred,forward,reverse', [
+    ('forward', .95, .03), ('reverse', .03, .95), ('unstranded', .49, .49)])
+@pytest.mark.parametrize('expected', ['forward', 'reverse', 'unstranded', 'fr', 'rf'])
+def test_verdict(tmp_path, paired, flat, inferred, forward, reverse, expected):
+    result, report = run_checker(tmp_path, infer_text(paired, forward, reverse), expected, flat)
+    match = checker.EXPECTED_ALIASES[expected] == inferred
+    assert result.returncode == (0 if match else 2), result.stderr
+    assert report['status'] == ('match' if match else 'mismatch')
+    assert report['inferred'] == inferred
+    assert report['paired'] is paired
+    if not match:
+        assert 'ERROR: strandedness mismatch for sample sample name' in result.stderr
+        assert 'SEQUENCING' in result.stderr
+
+
+@pytest.mark.parametrize('forward,reverse,failed,status', [
+    (.2, .2, .6, 'inconclusive'), (.49, .21, .3, 'ambiguous'),
+    (0, 0, 0, 'inconclusive'), (0, 0, 1, 'inconclusive'),
+    (.3333, .3333, .3333, 'mismatch')])
+def test_uncertainty_and_rounding(tmp_path, forward, reverse, failed, status):
+    result, report = run_checker(tmp_path, infer_text(True, forward, reverse, failed))
+    assert report['status'] == status
+    assert result.returncode == (2 if status == 'mismatch' else 0)
+    if status != 'mismatch':
+        assert 'WARNING: strandedness NOT validated' in result.stderr
+
+
+@pytest.mark.parametrize('forward,reverse,inferred', [
+    (.8, .2, 'forward'), (.2, .8, 'reverse'), (.4, .6, 'unstranded'),
+    (.6, .4, 'unstranded')])
+def test_threshold_boundaries(forward, reverse, inferred):
+    assert checker.infer_strandedness(0, forward, reverse) == inferred
+
+
+@pytest.mark.parametrize('text', [
+    '', infer_text() + 'Fraction of reads failed to determine: 0.0200\n',
+    infer_text().replace('0.9500', 'NaN'), infer_text().replace('0.9500', 'inf'),
+    infer_text().replace('0.9500', '-0.1'), infer_text().replace('0.9500', '1.1'),
+    infer_text().replace('0.9500', 'bad'), infer_text().replace('0.9500', '0.1'),
+    infer_text().replace('This is PairEnd Data\n', ''),
+    infer_text().replace('Fraction of reads failed to determine: 0.0200\n', ''),
+    infer_text().replace('1++,1--,2+-,2-+', 'unknown'),
+    infer_text() + 'Fraction of reads explained by "++,--": 0.1\n',
+    infer_text(False) + 'Fraction of reads explained by "1++,1--,2+-,2-+": 0.1\n',
+])
+def test_bad_report_fails(tmp_path, text):
+    result, report = run_checker(tmp_path, text)
+    assert result.returncode == 2
+    assert 'ERROR:' in result.stderr
+    assert report is None
+
+
+def test_pattern_whitespace(tmp_path):
+    result, report = run_checker(tmp_path, infer_text().replace(',', ', '))
+    assert result.returncode == 0
+    assert report['status'] == 'match'
+
+
+def test_missing_and_multiple_reports(tmp_path):
+    with pytest.raises(checker.StrandednessError, match='no .*found'):
+        checker.find_infer_file(tmp_path)
+    for name in ('a', 'b'):
+        (tmp_path / f'{name}.infer_experiment.txt').write_text(infer_text())
+    with pytest.raises(checker.StrandednessError, match='multiple'):
+        checker.find_infer_file(tmp_path)
+
+
+@pytest.fixture
+def fake_rustqc(tmp_path, monkeypatch):
+    """Only RustQC is stubbed; engines and the strand checker execute for real."""
+    bin_dir = tmp_path / 'bin'
+    bin_dir.mkdir()
+    stub = bin_dir / 'rustqc'
+    stub.write_text('#!/usr/bin/env python\n' +
+        'import os, pathlib, sys\n'
+        'args = sys.argv\n'
+        'out = pathlib.Path(args[args.index("-o") + 1])\n'
+        'out.mkdir(parents=True, exist_ok=True)\n'
+        '(out / "rustqc_summary.json").write_text("{}")\n'
+        '(out / "sample.infer_experiment.txt").write_text(os.environ["INFER_TEXT"])\n')
+    stub.chmod(0o755)
+    monkeypatch.setenv('PATH', str(bin_dir) + os.pathsep + os.environ.get('PATH', ''))
+    shutil.copy2(ROOT / 'envs/rustqc.yaml', tmp_path / 'rustqc.yaml')
+    bins = tmp_path / 'scripts with spaces'
+    (bins / 'Analysis').mkdir(parents=True)
+    shutil.copy2(CHECKER, bins / 'Analysis/check_strandedness.py')
+    (tmp_path / 'annotation with spaces.gtf').write_text('fixture annotation\n')
+    return bins
+
+
+@pytest.mark.parametrize('unique', [False, True])
+@pytest.mark.parametrize('mismatch', [False, True])
+def test_snakemake_gate(tmp_path, monkeypatch, fake_rustqc, unique, mismatch):
+    engine = shutil.which('snakemake')
+    if not engine:
+        pytest.skip('snakemake not on PATH')
+    monkeypatch.setenv('INFER_TEXT', infer_text())
+    bam = 'MAPPED/combo/sample_mapped_sorted' + ('_unique' if unique else '')
+    (tmp_path / bam).parent.mkdir(parents=True)
+    (tmp_path / (bam + '.bam')).touch()
+    (tmp_path / (bam + '.bam.bai')).touch()
+    out = bam.replace('MAPPED/', 'QC/')
+    prefix = (
+        "def env_bin_from_config(*args): return 'rustqc', 'rustqc'\n"
+        "def tool_params(*args): return {'OPTIONS': {}}\n"
+        "SAMPLES = ['sample']\nMAXTHREAD = 1\npaired = 'paired'\n"
+        f"stranded = {'rf' if mismatch else 'fr'!r}\n"
+        f"BINS = {str(fake_rustqc)!r}\nANNOTATION = 'annotation with spaces.gtf'\n"
+    )
+    downstream = (f'\nrule downstream:\n    input: "{out}/rustqc_summary.json"\n'
+                  '    output: "downstream.done"\n    shell: "touch {output}"\n')
+    snake = tmp_path / 'Snakefile'
+    snake.write_text(prefix + (ROOT / 'workflows/rustqc.smk').read_text() + downstream)
+    result = subprocess.run([engine, '-s', str(snake), '-j', '1', 'downstream.done'],
+                            capture_output=True, text=True, timeout=90)
+    assert (result.returncode != 0) is mismatch, result.stdout + result.stderr
+    assert (tmp_path / 'downstream.done').exists() is not mismatch
+    if mismatch:
+        logs = '\n'.join(p.read_text() for p in (tmp_path / 'LOGS').rglob('*.log'))
+        assert 'strandedness mismatch' in logs
+    else:
+        assert json.loads((tmp_path / out / 'strandedness_check.json').read_text())['status'] == 'match'
+
+
+@pytest.mark.parametrize('mismatch', [False, True])
+def test_nextflow_gate(tmp_path, monkeypatch, fake_rustqc, mismatch):
+    engine = shutil.which('nextflow')
+    if not engine:
+        pytest.skip('nextflow not on PATH')
+    from MONSDA.Workflows import nf_paramize
+    monkeypatch.setenv('INFER_TEXT', infer_text())
+    (tmp_path / 'sample.bam').touch()
+    values = dict(POSTQCENV='rustqc', POSTQCBIN='rustqc', rustqc_params_QC='',
+                  MAPPINGANNO='annotation with spaces.gtf')
+    prefix = (
+        'def get_always(key) {\n    return params[key]\n}\n'
+        f'BINS = {json.dumps(str(fake_rustqc))}\n'
+        f'STRANDED = {json.dumps("rf" if mismatch else "fr")}\n'
+        "PAIRED = 'paired'\nTHREADS = 1\nCOMBO = 'combo'\nCONDITION = 'condition'\n"
+    )
+    suffix = '''
+process downstream {
+    input:
+    path qc
+    output:
+    path 'downstream.done'
+    script:
+    "touch downstream.done"
+}
+workflow {
+    rustqc_mapped(Channel.fromPath('sample.bam'))
+    downstream(rustqc_mapped.out.rustqc_json)
+}
+'''
+    workflow = tmp_path / 'test.nf'
+    workflow.write_text(nf_paramize(prefix + (ROOT / 'workflows/rustqc.nf').read_text() + suffix))
+    params = tmp_path / 'params.json'
+    params.write_text(json.dumps(values))
+    result = subprocess.run([engine, 'run', str(workflow), '-params-file', str(params),
+                             '-work-dir', str(tmp_path / 'work')],
+                            capture_output=True, text=True, timeout=120)
+    assert (result.returncode != 0) is mismatch, result.stdout + result.stderr
+    markers = list((tmp_path / 'work').rglob('downstream.done'))
+    assert bool(markers) is not mismatch
+    reports = list((tmp_path / 'work').rglob('strandedness_check.json'))
+    assert reports, result.stdout + result.stderr
+    assert json.loads(reports[0].read_text())['status'] == ('mismatch' if mismatch else 'match')
+    if mismatch:
+        assert 'strandedness mismatch' in result.stdout + result.stderr
+        assert len(reports) == 1, 'Deterministic strand mismatch must not be retried'
+
+
+@pytest.mark.parametrize('stream', ['stdout', 'stderr', 'silent'])
+def test_runjob_failure_is_nonzero(stream):
+    from MONSDA.RunMONSDA import runjob
+    code = 'import sys; '
+    if stream != 'silent':
+        code += f'print("ERROR: strandedness mismatch", file=sys.{stream}); '
+    code += 'sys.exit(2)'
+    with pytest.raises(SystemExit) as exc:
+        runjob(shlex.join([sys.executable, '-c', code]))
+    assert exc.value.code not in (None, 0)
+
+
+def test_runjob_success():
+    from MONSDA.RunMONSDA import runjob
+    assert runjob(shlex.join([sys.executable, '-c', 'print("completed")'])) == 0
diff --git a/workflows/rustqc.nf b/workflows/rustqc.nf
index 7decbb9d..4a433820 100644
--- a/workflows/rustqc.nf
+++ b/workflows/rustqc.nf
@@ -22,6 +22,7 @@ process rustqc_mapped{
     cpus THREADS
     cache 'lenient'
     label 'big_mem'
+    errorStrategy { task.exitStatus == 2 ? 'terminate' : 'retry' }
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
     saveAs: {filename ->
@@ -39,7 +40,7 @@ process rustqc_mapped{
     fn = file(bam).getSimpleName()
     anno = file("${workflow.workDir}/../${MAPANNO}")
     """
-    mkdir -p results/$fn && gzip -cdfq $anno > tmp_anno.gtf && $RUSTQCBIN rna $bam --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j results/$fn/rustqc_summary.json -o results/$fn $RUSTQCPARAMS && rm -f tmp_anno.gtf
+    mkdir -p "results/$fn" && gzip -cdfq "$anno" > tmp_anno.gtf && $RUSTQCBIN rna "$bam" --gtf tmp_anno.gtf -t ${task.cpus} $RUSTQC_PAIRED -s $RUSTQC_STRANDED --skip-dup-check -j "results/$fn/rustqc_summary.json" -o "results/$fn" $RUSTQCPARAMS && python "${BINS}/Analysis/check_strandedness.py" --qc-dir "results/$fn" --expected "$RUSTQC_STRANDED" --sample "$fn" --report "results/$fn/strandedness_check.json" && rm -f tmp_anno.gtf
     """
 }
 
diff --git a/workflows/rustqc.smk b/workflows/rustqc.smk
index f8dafa0b..68035df0 100644
--- a/workflows/rustqc.smk
+++ b/workflows/rustqc.smk
@@ -24,8 +24,9 @@ rule rustqc_mapped:
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', ""),
              anno = ANNOTATION,
              paired = RUSTQC_PAIRED,
-             stranded = RUSTQC_STRANDED
-    shell: "gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"
+             stranded = RUSTQC_STRANDED,
+             bins = BINS
+    shell: "(gzip -cdfq {params.anno:q} > {output.tmpanno:q} && rustqc rna {input.r1:q} --gtf {output.tmpanno:q} -t {threads} {params.paired} -s {params.stranded:q} --skip-dup-check -j {output.js:q} -o {output.o1:q} {params.qpara} && python {params.bins:q}/Analysis/check_strandedness.py --qc-dir {output.o1:q} --expected {params.stranded:q} --sample {wildcards.file:q} --report {output.o1:q}/strandedness_check.json) 2> {log:q}"
 
 rule rustqc_uniquemapped:
     input:  r1 = "MAPPED/{combo}/{file}_mapped_sorted_unique.bam",
@@ -40,5 +41,6 @@ rule rustqc_uniquemapped:
     params:  qpara = lambda wildcards: tool_params(SAMPLES[0], None, config, 'QC', QCENV)['OPTIONS'].get('QC', ""),
              anno = ANNOTATION,
              paired = RUSTQC_PAIRED,
-             stranded = RUSTQC_STRANDED
-    shell: "gzip -cdfq {params.anno} > {output.tmpanno} && rustqc rna {input.r1} --gtf {output.tmpanno} -t {threads} {params.paired} -s {params.stranded} --skip-dup-check -j {output.js} -o {output.o1} {params.qpara} 2> {log}"
+             stranded = RUSTQC_STRANDED,
+             bins = BINS
+    shell: "(gzip -cdfq {params.anno:q} > {output.tmpanno:q} && rustqc rna {input.r1:q} --gtf {output.tmpanno:q} -t {threads} {params.paired} -s {params.stranded:q} --skip-dup-check -j {output.js:q} -o {output.o1:q} {params.qpara} && python {params.bins:q}/Analysis/check_strandedness.py --qc-dir {output.o1:q} --expected {params.stranded:q} --sample {wildcards.file:q} --report {output.o1:q}/strandedness_check.json) 2> {log:q}"

From f36dc302ccd79adf20024e18577a15fcee3ee79e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 21:03:04 +0200
Subject: [PATCH 67/80] DE spike-in fixes

---
 scripts/Analysis/DE/DESEQ2.R       |  7 +++--
 scripts/Analysis/DE/EDGER.R        | 21 ++++++++------
 scripts/Analysis/DE/EDGER_no_rep.R | 45 ++++++++++++++++--------------
 3 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 45cf78e4..9beb9314 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -256,13 +256,14 @@ for (contrast in comparison) {
         setwd(outdir)
 
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
+        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
         sampleData_norm <- cbind(sampleData, pData(counts_norm))
         design_norm <- as.formula(paste(gsub("~", "~ W_1 +", deparse(design)), collapse = ""))  # Last argument is variable of interest
         #design_norm <- as.formula(paste(deparse(design), " + W_1"), collapse = "")
-        print(paste0("Design with spike-in normalization: ", paste(colnames(design_norm), collapse = ", ")))
+        print(paste0("Design with spike-in normalization: ", paste(all.vars(design_norm), collapse = ", ")))
 
-        dds_norm <- DESeqDataSetFromMatrix(countData = counts(counts_norm), colData = sampleData_norm, design = design_norm)
+        dds_norm <- DESeqDataSetFromMatrix(countData = counts_norm_mat, colData = sampleData_norm, design = design_norm)
         # filter low counts
         smallestGroupSize <- min_group_size(sampleData_norm$condition)
         keep_norm <- rowSums(counts(dds_norm) >= 10) >= smallestGroupSize
@@ -400,7 +401,7 @@ for (contrast in comparison) {
             # add comp object to list for image
             listname <- paste(contrast_name, "_norm", sep = "")
             if (postde_enabled) {
-                postde_capture(engine = "deseq2", id = listname, A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = as.matrix(counts(counts_norm)), expression = assay(vsd_norm), formula = design_norm, results = postde_results_deseq2(res), mean_scale = "baseMean")
+                postde_capture(engine = "deseq2", id = listname, A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = counts_norm_mat, expression = assay(vsd_norm), formula = design_norm, results = postde_results_deseq2(res), mean_scale = "baseMean")
             }
             comparison_objs[[listname]] <- res
 
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 2fa63ce1..4ca550c7 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -249,15 +249,16 @@ for (contrast in comparison) {
         ctrlgenes <- readLines(spiken)
         setwd(outdir)
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
-        genes <- rownames(counts(counts_norm))
+        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
+        genes <- rownames(counts_norm_mat)
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
         sampleData_norm <- cbind(sampleData, pData(counts_norm))        
         des_norm <- as.formula(paste(gsub("~", "~ W_1 +", deparse(des)), collapse = ""))  # Last argument is variable of interest
         # des_norm <- as.formula(paste(deparse(des), " + W_1"), collapse = "")
         design_norm <- model.matrix(des_norm, data = sampleData_norm)
-        print(paste0("Design with spike-in normalization: ", paste(colnames(design_norm), collapse = ", ")))        
+        print(paste0("Design with spike-in normalization: ", paste(colnames(design_norm), collapse = ", ")))
 
-        dge_norm <- DGEList(counts = counts(counts_norm), group = sampleData$condition, samples = samples, genes = genes)
+        dge_norm <- DGEList(counts = counts_norm_mat, group = sampleData$condition, samples = samples, genes = genes)
         ## filter low counts
         keep <- filterByExpr(dge_norm)
         dge_norm <- dge_norm[keep, , keep.lib.sizes = FALSE]
@@ -440,13 +441,13 @@ for (contrast in comparison) {
 
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-        tops <- tops$table[, c(7, 6, 3, 2, 4, 5, 8)]
+        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "F", "PValue", "FDR")]
         tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-        tops <- tops$table[, c(7, 6, 3, 2, 4, 5, 8)]
+        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "F", "PValue", "FDR")]
         tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
@@ -486,9 +487,9 @@ for (contrast in comparison) {
             qlf <- glmQLFTest(fit_norm, contrast = AvsB) ## glm quasi-likelihood-F-Test
             # add comp object to list for image
             if (postde_enabled) {
-                postde_capture(engine = "edger", id = paste0(contrast_name, "_norm"), A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = as.matrix(counts(counts_norm)), expression = cpm(dge_norm, log = TRUE), formula = des_norm, results = postde_results_edger(qlf), mean_scale = "logCPM")
+                postde_capture(engine = "edger", id = paste0(contrast_name, "_norm"), A = A, B = B, normalized = TRUE, metadata = sampleData_norm, counts = counts_norm_mat, expression = cpm(dge_norm, log = TRUE), formula = des_norm, results = postde_results_edger(qlf), mean_scale = "logCPM")
             }
-            comparison_objs <- append(comparison_objs, qlf)
+            comparison_objs[[paste0(contrast_name, "_norm")]] <- qlf
 
             # # Add gene names  (check how gene_id col is named )
             qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
@@ -532,13 +533,13 @@ for (contrast in comparison) {
 
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-            tops <- tops$table[, c(7, 6, 4, 2, 3, 5, 8)]
+            tops <- tops$table[, c("Gene_ID", "Gene", "logFC", "logCPM", "F", "PValue", "FDR")]
             tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-            tops <- tops$table[, c(7, 6, 4, 2, 3, 5, 8)]
+            tops <- tops$table[, c("Gene_ID", "Gene", "logFC", "logCPM", "F", "PValue", "FDR")]
             tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
@@ -554,6 +555,8 @@ for (contrast in comparison) {
         # cleanup
         rm(qlf, res, tops)
         print(paste("cleanup done for ", contrast_name, sep = ""))
+    }, error = function(e) {
+        message(paste0("Error while processing contrast ", contrast_name, ": ", conditionMessage(e), ". Skipping this contrast."))
     })
 }
 
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index dd02894e..001d590d 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -54,7 +54,8 @@ sampleData_all$type <- as.factor(sampleData_all$type)
 samples <- rownames(sampleData_all)
 
 ## Combinations of conditions
-comparison <- strsplit(cmp, ",")
+comparison <- parse_comparisons(cmp)
+validate_comparisons(comparison, levels(sampleData_all$condition))
 
 ## check combi
 if (combi == "none") {
@@ -117,20 +118,19 @@ out <- paste("Figures/DE", "EDGER", combi, "DataSet", "figure", "AllConditionsQL
 png::writePNG(array(0, dim = c(1,1,4)), out)
 
 ## Analyze according to comparison groups
-for (contrast in comparison[[1]]) {
-    contrast_name <- strsplit(contrast, ":")[[1]][1]
-    contrast_groups <- strsplit(strsplit(contrast, ":")[[1]][2], "-vs-")
+for (contrast in comparison) {
+    contrast_name <- contrast$name
 
     print(paste("Comparing ", contrast_name, sep = ""))
 
     # determine contrast
-    A <- unlist(strsplit(contrast_groups[[1]][1], "\\+"), use.names = FALSE)
-    B <- unlist(strsplit(contrast_groups[[1]][2], "\\+"), use.names = FALSE)
+    A <- contrast$A
+    B <- contrast$B
 
-    # subset Datasets for pairwise comparison
-    countData <- cbind(countData_all[, grepl(paste("^", B, "_", sep = ""), colnames(countData_all))], countData_all[, grepl(paste("^", A, "_", sep = ""), colnames(countData_all))])
-    rownames(countData) <- rownames(countData_all)
-    sampleData <- droplevels(rbind(subset(sampleData_all, B == condition), subset(sampleData_all, A == condition)))
+    # subset Datasets for pairwise comparison: metadata-based selection, B then A order
+    sel <- select_contrast_samples(sampleData_all, countData_all, A, B)
+    sampleData <- sel$sampleData
+    countData <- sel$countData
     sampleData$condition <- relevel(sampleData$condition, ref = B)
 
     samples <- rownames(sampleData)
@@ -165,19 +165,20 @@ for (contrast in comparison[[1]]) {
     ## check genes and spike-ins
     if (spike != "") {
         print("Spike-in used, data will be normalized to spike in separately")
-        spike <- strsplit(spike, "=")[[1]][2]
+        spiken <- strsplit(spike, "=")[[1]][2]
         setwd(WD)
-        ctrlgenes <- readLines(spike)
+        ctrlgenes <- readLines(spiken)
         setwd(outdir)
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
-        genes <- rownames(countData)
+        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
+        genes <- rownames(counts_norm_mat)
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
 
         sampleData_norm <- cbind(sampleData, pData(counts_norm))
         design_norm <- model.matrix(as.formula(paste(deparse(des), colnames(pData(counts_norm))[1], sep = " + ")), data = sampleData_norm)
         # colnames(design_norm) <- c(colnames(design),"W_1")
 
-        dge_norm <- DGEList(counts = counts(counts_norm), group = sampleData$condition, samples = samples, genes = genes)
+        dge_norm <- DGEList(counts = counts_norm_mat, group = sampleData$condition, samples = samples, genes = genes)
 
         ## filter low counts
         keep <- filterByExpr(dge_norm)
@@ -321,13 +322,13 @@ for (contrast in comparison[[1]]) {
 
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-        tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
         tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-        tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
         tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
@@ -363,7 +364,7 @@ for (contrast in comparison[[1]]) {
             #qlf <- glmQLFTest(fit, contrast = AvsB) ## glm quasi-likelihood-F-Test
             qlf <- exactTest(dge_norm, pair = c(B, A), dispersion = bcv^2, prior.count = 2)
             # add comp object to list for image
-            comparison_objs <- append(comparison_objs, qlf)
+            comparison_objs[[paste0(contrast_name, "_norm")]] <- qlf
 
             # # Add gene names  (check how gene_id col is named )
             qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
@@ -380,8 +381,8 @@ for (contrast in comparison[[1]]) {
             )
             print(EnhancedVolcano(res,
                 lab = res$Gene,
-                x = as.numeric("logFC"),
-                y = as.numeric("FDR"),
+                x = "logFC",
+                y = "FDR",
                 title = paste0(contrast_name, "_p005_lfc15", sep = ""),
                 pCutoff = 0.05,
                 FCcutoff = 1.5,
@@ -407,13 +408,13 @@ for (contrast in comparison[[1]]) {
 
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-            tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+            tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
             tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-            tops <- tops$table[, c(6, 5, 3, 2, 4, 7)]
+            tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
             tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
@@ -429,6 +430,8 @@ for (contrast in comparison[[1]]) {
         # cleanup
         rm(qlf, res, tops)
         print(paste("cleanup done for ", contrast_name, sep = ""))
+    }, error = function(e) {
+        message(paste0("Error while processing contrast ", contrast_name, ": ", conditionMessage(e), ". Skipping this contrast."))
     })
 }
 

From 7c2ba0e8cdb64cdcb6efcdca5df1fc43a2067123 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 21:13:17 +0200
Subject: [PATCH 68/80] proper spike-in size factor correction applied

---
 scripts/Analysis/DE/DESEQ2.R       | 11 +++++++++--
 scripts/Analysis/DE/EDGER.R        | 16 +++++++++++-----
 scripts/Analysis/DE/EDGER_no_rep.R | 16 +++++++++++-----
 3 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 9beb9314..3558bad9 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -256,14 +256,21 @@ for (contrast in comparison) {
         setwd(outdir)
 
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
-        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
+        ctrl_idx <- rownames(counts(counts_norm)) %in% ctrlgenes # for spike-in-derived size factors
+        counts_norm_mat <- counts(counts_norm)[!ctrl_idx, , drop = FALSE] # removing spike-ins for actual DE testing
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
         sampleData_norm <- cbind(sampleData, pData(counts_norm))
         design_norm <- as.formula(paste(gsub("~", "~ W_1 +", deparse(design)), collapse = ""))  # Last argument is variable of interest
         #design_norm <- as.formula(paste(deparse(design), " + W_1"), collapse = "")
         print(paste0("Design with spike-in normalization: ", paste(all.vars(design_norm), collapse = ", ")))
 
-        dds_norm <- DESeqDataSetFromMatrix(countData = counts_norm_mat, colData = sampleData_norm, design = design_norm)
+        # Build with the full (incl. spike-in) counts so that size factors can be derived from the
+        # spike-ins themselves (controlGenes); this is what puts the spike-in scale into the
+        # normalized results, the W_1 covariate alone only adjusts for unwanted variation, not scale.
+        dds_norm <- DESeqDataSetFromMatrix(countData = counts(counts_norm), colData = sampleData_norm, design = design_norm)
+        dds_norm <- estimateSizeFactors(dds_norm, controlGenes = ctrl_idx)
+        dds_norm <- dds_norm[!ctrl_idx, ] # drop spike-ins from testing, size factors are retained
+
         # filter low counts
         smallestGroupSize <- min_group_size(sampleData_norm$condition)
         keep_norm <- rowSums(counts(dds_norm) >= 10) >= smallestGroupSize
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 4ca550c7..0ec5866e 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -249,7 +249,8 @@ for (contrast in comparison) {
         ctrlgenes <- readLines(spiken)
         setwd(outdir)
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
-        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
+        ctrl_idx <- rownames(counts(counts_norm)) %in% ctrlgenes # for spike-in-derived normalization factors
+        counts_norm_mat <- counts(counts_norm)[!ctrl_idx, , drop = FALSE] # removing spike-ins for actual DE testing
         genes <- rownames(counts_norm_mat)
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
         sampleData_norm <- cbind(sampleData, pData(counts_norm))        
@@ -259,15 +260,20 @@ for (contrast in comparison) {
         print(paste0("Design with spike-in normalization: ", paste(colnames(design_norm), collapse = ", ")))
 
         dge_norm <- DGEList(counts = counts_norm_mat, group = sampleData$condition, samples = samples, genes = genes)
-        ## filter low counts
+        ## filter low counts; keep original (pre-filter) lib sizes since the spike-in-derived
+        ## normalization factors below are only valid relative to them
         keep <- filterByExpr(dge_norm)
-        dge_norm <- dge_norm[keep, , keep.lib.sizes = FALSE]
+        dge_norm <- dge_norm[keep, , keep.lib.sizes = TRUE]
 
         # relevel to base condition B
         dge_norm$samples$group <- relevel(dge_norm$samples$group, ref = B[[1]])
 
-        ## normalize with TMM
-        dge_norm <- calcNormFactors(dge_norm, method = "TMM", BPPARAM = BPPARAM)
+        ## normalize using the spike-in (control gene) counts rather than TMM on the endogenous
+        ## genes: this is what actually puts the spike-in scale into the normalized results, the
+        ## W_1 covariate alone only adjusts for unwanted variation, not scale.
+        spike_counts <- counts(counts_norm)[ctrl_idx, , drop = FALSE]
+        dge_spike <- calcNormFactors(DGEList(counts = spike_counts), method = "TMM")
+        dge_norm$samples$norm.factors <- dge_spike$samples$norm.factors
 
         ## create file normalized table
         tmm_norm <- as.data.frame(cpm(dge_norm))
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index 001d590d..58e3e8f2 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -170,7 +170,8 @@ for (contrast in comparison) {
         ctrlgenes <- readLines(spiken)
         setwd(outdir)
         counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData)), ctrlgenes, k = 1)
-        counts_norm_mat <- counts(counts_norm)[!(rownames(counts(counts_norm)) %in% ctrlgenes), , drop = FALSE] # removing spike-ins for actual DE testing
+        ctrl_idx <- rownames(counts(counts_norm)) %in% ctrlgenes # for spike-in-derived normalization factors
+        counts_norm_mat <- counts(counts_norm)[!ctrl_idx, , drop = FALSE] # removing spike-ins for actual DE testing
         genes <- rownames(counts_norm_mat)
         countData <- countData %>% subset(!row.names(countData) %in% ctrlgenes) # removing spike-ins for standard analysis
 
@@ -180,15 +181,20 @@ for (contrast in comparison) {
 
         dge_norm <- DGEList(counts = counts_norm_mat, group = sampleData$condition, samples = samples, genes = genes)
 
-        ## filter low counts
+        ## filter low counts; keep original (pre-filter) lib sizes since the spike-in-derived
+        ## normalization factors below are only valid relative to them
         keep <- filterByExpr(dge_norm)
-        dge_norm <- dge_norm[keep, , keep.lib.sizes = FALSE]
+        dge_norm <- dge_norm[keep, , keep.lib.sizes = TRUE]
 
         # relevel to base condition B
         dge_norm$samples$group <- relevel(dge_norm$samples$group, ref = B[[1]])
 
-        ## normalize with TMM
-        dge_norm <- calcNormFactors(dge_norm, method = "TMM", BPPARAM = BPPARAM)
+        ## normalize using the spike-in (control gene) counts rather than TMM on the endogenous
+        ## genes: this is what actually puts the spike-in scale into the normalized results, the
+        ## W_1 covariate alone only adjusts for unwanted variation, not scale.
+        spike_counts <- counts(counts_norm)[ctrl_idx, , drop = FALSE]
+        dge_spike <- calcNormFactors(DGEList(counts = spike_counts), method = "TMM")
+        dge_norm$samples$norm.factors <- dge_spike$samples$norm.factors
 
         ## create file normalized table
         tmm_norm <- as.data.frame(cpm(dge_norm))

From 6bb7db87de90c90b37e8dd27f4415669fed3e98a Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Tue, 6 Oct 2026 21:24:59 +0200
Subject: [PATCH 69/80] cleanup

---
 scripts/Analysis/DEU/EDGER.R | 1 -
 1 file changed, 1 deletion(-)

diff --git a/scripts/Analysis/DEU/EDGER.R b/scripts/Analysis/DEU/EDGER.R
index 6511bafa..842c2508 100755
--- a/scripts/Analysis/DEU/EDGER.R
+++ b/scripts/Analysis/DEU/EDGER.R
@@ -17,7 +17,6 @@ outdir <- args[4]
 cmp <- args[5]
 combi <- args[6]
 availablecores <- as.integer(args[7])
-spike <- if (argsLen > 7) args[8] else ""
 
 print(args)
 

From fe75c70f3bed73b193c1e3df02e06d753f292f7f Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 7 Oct 2026 14:13:02 +0200
Subject: [PATCH 70/80] Update to Readme

---
 README.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/README.md b/README.md
index 1b896fb0..915dfe27 100644
--- a/README.md
+++ b/README.md
@@ -84,6 +84,30 @@ monsda --nextflow -j ${THREADS} --configfile ${CONFIG}.json --directory ${PWD}
 ```
 and add additional arguments for ```Nextflow``` as you see fit.
 
+### Rerunning on an existing analysis while skipping specific steps
+
+When rerunning MONSDA on an already-existing analysis directory, keep the full,
+original ```WORKFLOWS``` list in the config (e.g. keep ```QC```, ```TRIMMING```,
+```MAPPING```, ```DEDUP``` listed alongside ```DE```/```DEU```/```DAS```/```DTU```)
+even if you only care about one of the later steps. ```MONSDA``` derives the
+```combo```/```scombo``` tool-chain names (used to locate existing output
+directories, e.g. ```MAPPED/fastqc-bbduk-picard-bwa/...```) from which stages
+are listed in ```WORKFLOWS```; dropping an earlier stage such as ```QC``` from
+the list changes those names and makes ```Snakemake|Nextflow``` treat the
+existing outputs as missing, forcing a full rerun from scratch.
+
+To still skip execution of a specific rule (e.g. avoid rerunning ```multiqc```
+against outputs generated by an older MONSDA version) without removing it from
+```WORKFLOWS```, pass Snakemake's own ```--omit-from``` as an additional
+argument:
+
+```
+monsda -j ${THREADS} --configfile ${CONFIG}.json --directory ${PWD} --omit-from multiqc
+```
+
+This prevents execution of the given rule (and anything downstream of it)
+while leaving the rest of the DAG, and the already-up-to-date outputs it
+depends on, untouched.
 
 ### Run on workload manager
 

From 223066c88d71477f843e0175444387f750c96aa4 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Wed, 7 Oct 2026 15:00:45 +0200
Subject: [PATCH 71/80] spike-in normalization perpetuated to norm tables for
 tpm/cpm calculation properly

---
 scripts/Analysis/DE/DESEQ2.R | 11 ++++++++---
 scripts/Analysis/DE/EDGER.R  | 13 ++++++++++---
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 3558bad9..33fd5c35 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -110,9 +110,14 @@ if (spike != "") {
     setwd(WD)
     ctrlgenes <- readLines(spiken)
     setwd(outdir)
-    counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData_all)), ctrlgenes, k = 1)
-    sampleData_norm <- cbind(sampleData_all, pData(counts_norm))
-    counts_norm <- as.data.frame(normCounts(counts_norm))
+    counts_norm_set <- RUVg(newSeqExpressionSet(as.matrix(countData_all)), ctrlgenes, k = 1)
+    sampleData_norm <- cbind(sampleData_all, pData(counts_norm_set))
+    ctrl_idx_all <- rownames(counts(counts_norm_set)) %in% ctrlgenes # for spike-in-derived size factors
+    # Derive size factors from the spike-ins themselves (controlGenes); normCounts() from RUVg
+    # only removes unwanted variation (W_1) and does not carry the spike-in scale.
+    dds_sf <- DESeqDataSetFromMatrix(countData = counts(counts_norm_set), colData = sampleData_norm, design = ~1)
+    dds_sf <- estimateSizeFactors(dds_sf, controlGenes = ctrl_idx_all)
+    counts_norm <- as.data.frame(counts(dds_sf, normalized = TRUE))
     countData_clean <- countData_all %>% subset(!row.names(countData_all) %in% ctrlgenes) # removing spike-ins for standard analysis
     counts_norm_clean <- counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes) # removing spike-ins for standard analysis
      write.table(add_gene_coordinates(counts_norm, rownames(counts_norm), gtf_gene), gzfile(paste("Tables/DE", "DESEQ2", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 0ec5866e..89769306 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -127,9 +127,16 @@ if (spike != "") {
     setwd(WD)
     ctrlgenes <- readLines(spiken)
     setwd(outdir)
-    counts_norm <- RUVg(newSeqExpressionSet(as.matrix(countData_all)), ctrlgenes, k = 1)
-    sampleData_norm <- cbind(sampleData_all, pData(counts_norm))
-    counts_norm <- as.data.frame(normCounts(counts_norm))
+    counts_norm_set <- RUVg(newSeqExpressionSet(as.matrix(countData_all)), ctrlgenes, k = 1)
+    sampleData_norm <- cbind(sampleData_all, pData(counts_norm_set))
+    ctrl_idx_all <- rownames(counts(counts_norm_set)) %in% ctrlgenes # for spike-in-derived normalization factors
+    # Derive the scale from the spike-ins (TMM on control genes) rather than RUVg's normCounts(),
+    # which only removes unwanted variation (W_1) and does not carry the spike-in scale.
+    spike_counts_all <- counts(counts_norm_set)[ctrl_idx_all, , drop = FALSE]
+    dge_spike_all <- calcNormFactors(DGEList(counts = spike_counts_all), method = "TMM")
+    eff_lib_all <- dge_spike_all$samples$lib.size * dge_spike_all$samples$norm.factors
+    size_factor_all <- eff_lib_all / exp(mean(log(eff_lib_all)))
+    counts_norm <- as.data.frame(sweep(counts(counts_norm_set), 2, size_factor_all, FUN = "/"))
     countData_clean <- countData_all %>% subset(!row.names(countData_all) %in% ctrlgenes) # removing spike-ins for standard analysis
     counts_norm_clean <- counts_norm %>% subset(!row.names(counts_norm) %in% ctrlgenes) # removing spike-ins for standard analysis
     write.table(add_gene_coordinates(counts_norm, rownames(counts_norm), gtf_gene), gzfile(paste("Tables/DE", "EDGER", combi, "DataSet", "table", "counts_norm.tsv.gz", sep = "_")), sep = "\t", col.names = NA, quote = FALSE)

From ad5c4b3c2036c32cb7371e4df3ed49aab790564a Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 8 Oct 2026 13:15:10 +0200
Subject: [PATCH 72/80] fixed naming convention across DE tools, added global
 shift output to spikein normalized DE output

---
 scripts/Analysis/DE/DESEQ2.R       |  4 +-
 scripts/Analysis/DE/EDGER.R        | 36 +++++------------
 scripts/Analysis/DE/EDGER_no_rep.R | 36 +++++------------
 scripts/lib/_lib.R                 | 63 +++++++++++++++++++++++++++++-
 workflows/deseq2_DE.nf             |  2 +-
 workflows/edger_DE.nf              |  2 +-
 workflows/edger_DE.smk             |  5 ++-
 7 files changed, 89 insertions(+), 59 deletions(-)

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 33fd5c35..51f5bad4 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -421,7 +421,7 @@ for (contrast in comparison) {
             resOrdered <- res_shrink[order(res_shrink$log2FoldChange), ]
 
             # # Add gene names  (check how gene_id col is named )
-            resOrdered <- format_deseq2_results(resOrdered, gtf_gene, shrink = TRUE)
+            resOrdered <- format_deseq2_results(resOrdered, gtf_gene, shrink = TRUE, center = TRUE)
 
             # plot Volcano
             pdf(
@@ -461,7 +461,7 @@ for (contrast in comparison) {
                 get_gene_name(x, gtf_gene)
             }))
             res$Gene_ID <- rownames(res)
-            res <- format_deseq2_results(res, gtf_gene, shrink = FALSE)
+            res <- format_deseq2_results(res, gtf_gene, shrink = FALSE, center = TRUE)
             res <- as.data.frame(apply(res, 2, as.character))
 
             write.table(as.data.frame(res), gzfile(paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "results_norm_noshrink.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 89769306..2365d117 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -413,13 +413,7 @@ for (contrast in comparison) {
         comparison_objs[[contrast_name]] <- qlf
 
         # # Add gene names  (check how gene_id col is named )
-        qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
-            get_gene_name(x, gtf_gene)
-        }))
-        qlf$table$Gene_ID <- rownames(qlf$table)
-        res <- qlf$table[, c(6, 5, 2, 1, 3, 4)]
-        res$FDR <- p.adjust(res$PValue, method = "BH")
-        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+        res <- format_edger_results(qlf$table, gtf_gene)
 
         # plotVolcano
         pdf(
@@ -427,8 +421,8 @@ for (contrast in comparison) {
         )
         print(EnhancedVolcano(res,
             lab = res$Gene,
-            x = "logFC",
-            y = "FDR",
+            x = "log2FoldChange",
+            y = "padj",
             title = paste0(contrast_name, "_p005_lfc15", sep = ""),
             pCutoff = 0.05,
             FCcutoff = 1.5,
@@ -454,14 +448,12 @@ for (contrast in comparison) {
 
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "F", "PValue", "FDR")]
-        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+        tops <- format_edger_results(tops$table, gtf_gene)
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "F", "PValue", "FDR")]
-        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+        tops <- format_edger_results(tops$table, gtf_gene)
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -505,13 +497,7 @@ for (contrast in comparison) {
             comparison_objs[[paste0(contrast_name, "_norm")]] <- qlf
 
             # # Add gene names  (check how gene_id col is named )
-            qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
-                get_gene_name(x, gtf_gene)
-            }))
-            qlf$table$Gene_ID <- rownames(qlf$table)
-            res <- qlf$table[, c(6, 5, 1, 2, 3, 4)]
-            res$FDR <- p.adjust(res$PValue, method = "BH")
-            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+            res <- format_edger_results(qlf$table, gtf_gene, center = TRUE)
 
             # plotVolcano
             pdf(
@@ -519,8 +505,8 @@ for (contrast in comparison) {
             )
             print(EnhancedVolcano(res,
                 lab = res$Gene,
-                x = "logFC",
-                y = "FDR",
+                x = "log2FoldChange",
+                y = "padj",
                 title = paste0(contrast_name, "_p005_lfc15", sep = ""),
                 pCutoff = 0.05,
                 FCcutoff = 1.5,
@@ -546,14 +532,12 @@ for (contrast in comparison) {
 
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-            tops <- tops$table[, c("Gene_ID", "Gene", "logFC", "logCPM", "F", "PValue", "FDR")]
-            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+            tops <- format_edger_results(tops$table, gtf_gene, center = TRUE)
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-            tops <- tops$table[, c("Gene_ID", "Gene", "logFC", "logCPM", "F", "PValue", "FDR")]
-            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+            tops <- format_edger_results(tops$table, gtf_gene, center = TRUE)
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index 58e3e8f2..199085a2 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -287,13 +287,7 @@ for (contrast in comparison) {
         comparison_objs[[contrast_name]] <- qlf
 
         # # Add gene names  (check how gene_id col is named )
-        qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
-            get_gene_name(x, gtf_gene)
-        }))
-        qlf$table$Gene_ID <- rownames(qlf$table)
-        res <- qlf$table[, c(5, 4, 2, 1, 3)]
-        res$FDR <- p.adjust(res$PValue, method = "BH")
-        res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+        res <- format_edger_results(qlf$table, gtf_gene)
 
         # plotVolcano
         pdf(
@@ -301,8 +295,8 @@ for (contrast in comparison) {
         )
         print(EnhancedVolcano(res,
             lab = res$Gene,
-            x = "logFC",
-            y = "FDR",
+            x = "log2FoldChange",
+            y = "padj",
             title = paste0(contrast_name, "_p005_lfc15", sep = ""),
             pCutoff = 0.05,
             FCcutoff = 1.5,
@@ -328,14 +322,12 @@ for (contrast in comparison) {
 
         # create sorted results Tables
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
-        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+        tops <- format_edger_results(tops$table, gtf_gene)
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
         tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-        tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
-        tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+        tops <- format_edger_results(tops$table, gtf_gene)
         tops <- as.data.frame(apply(tops, 2, as.character))
         write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
@@ -373,13 +365,7 @@ for (contrast in comparison) {
             comparison_objs[[paste0(contrast_name, "_norm")]] <- qlf
 
             # # Add gene names  (check how gene_id col is named )
-            qlf$table$Gene <- unlist(lapply(rownames(qlf$table), function(x) {
-                get_gene_name(x, gtf_gene)
-            }))
-            qlf$table$Gene_ID <- rownames(qlf$table)
-            res <- qlf$table[, c(5, 4, 2, 1, 3)]
-            res$FDR <- p.adjust(res$PValue, method = "BH")
-            res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
+            res <- format_edger_results(qlf$table, gtf_gene, center = TRUE)
 
             # plotVolcano
             pdf(
@@ -387,8 +373,8 @@ for (contrast in comparison) {
             )
             print(EnhancedVolcano(res,
                 lab = res$Gene,
-                x = "logFC",
-                y = "FDR",
+                x = "log2FoldChange",
+                y = "padj",
                 title = paste0(contrast_name, "_p005_lfc15", sep = ""),
                 pCutoff = 0.05,
                 FCcutoff = 1.5,
@@ -414,14 +400,12 @@ for (contrast in comparison) {
 
             # create sorted results Tables
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "logFC")
-            tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
-            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+            tops <- format_edger_results(tops$table, gtf_gene, center = TRUE)
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsLogFCsorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
             tops <- topTags(qlf, n = nrow(qlf$table), sort.by = "PValue")
-            tops <- tops$table[, c("Gene_ID", "Gene", "logCPM", "logFC", "PValue", "FDR")]
-            tops <- add_gene_coordinates(tops, tops$Gene_ID, gtf_gene, after = "Gene_ID")
+            tops <- format_edger_results(tops$table, gtf_gene, center = TRUE)
             tops <- as.data.frame(apply(tops, 2, as.character))
             write.table(tops, gzfile(paste("Tables/DE", "EDGER", combi, contrast_name, "table", "resultsPValueSorted_norm.tsv.gz", sep = "_")), sep = "\t", quote = F, row.names = FALSE)
 
diff --git a/scripts/lib/_lib.R b/scripts/lib/_lib.R
index 90086eed..e1ae4921 100644
--- a/scripts/lib/_lib.R
+++ b/scripts/lib/_lib.R
@@ -171,10 +171,26 @@ select_contrast_samples <- function(sampleData_all, countData_all, A, B) {
     list(sampleData = sampleData, countData = countData)
 }
 
+## Global shift of a contrast: the median log fold change over all tested genes.
+## Under spike-in normalization this offset is the overall expression change
+## between the two conditions, which conventional normalization would have
+## scaled away. Subtracting it leaves each gene's own deviation from that shift.
+lfc_global_shift <- function(lfc) {
+    vals <- lfc[is.finite(lfc)]
+    if (length(vals) == 0) {
+        message("WARNING: no finite log fold changes, global shift set to 0")
+        return(0)
+    }
+    median(vals)
+}
+
 ## Format a DESeq2 results object for export: add gene name and ID, select the
 ## canonical column order by name and append genomic coordinates after Gene_ID.
 ## Shrunk tables carry no stat column; raw (unshrunk) tables append stat last.
-format_deseq2_results <- function(res, gtf_gene, shrink = TRUE) {
+## With center = TRUE a log2FoldChange_centered column is appended last, holding
+## the deviation from the contrast's global shift. It is appended rather than
+## inserted because the significance filters address columns by position.
+format_deseq2_results <- function(res, gtf_gene, shrink = TRUE, center = FALSE) {
     res$Gene <- unlist(lapply(rownames(res), function(x) {
         get_gene_name(x, gtf_gene)
     }))
@@ -184,5 +200,50 @@ format_deseq2_results <- function(res, gtf_gene, shrink = TRUE) {
     } else {
         res <- res[, c("Gene_ID", "Gene", "baseMean", "log2FoldChange", "lfcSE", "pvalue", "padj", "stat")]
     }
+    if (center) {
+        shift <- lfc_global_shift(res$log2FoldChange)
+        message(paste0("Global shift (median log2FoldChange) subtracted in log2FoldChange_centered: ", shift))
+        res$log2FoldChange_centered <- res$log2FoldChange - shift
+    }
     add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
 }
+
+## Format an edgeR result table (qlf$table or a topTags table) for export.
+## Column names follow the DESeq2 template so both engines emit the same header:
+## logFC -> log2FoldChange, PValue -> pvalue, BH-adjusted p -> padj, and the test
+## statistic (F for quasi-likelihood, LR for likelihood ratio) -> stat. logCPM
+## keeps its own name on purpose: it is a log-scale mean and is not the same
+## quantity as DESeq2's baseMean. Tests without a statistic column (exactTest)
+## simply omit stat. With center = TRUE the deviation from the contrast's global
+## shift is appended last as log2FoldChange_centered.
+format_edger_results <- function(tbl, gtf_gene, center = FALSE) {
+    tbl <- as.data.frame(tbl)
+    for (required in c("logFC", "logCPM", "PValue")) {
+        if (!required %in% colnames(tbl)) {
+            stop(paste0("format_edger_results: missing required column ", required))
+        }
+    }
+    gene_ids <- rownames(tbl)
+    out <- data.frame(
+        Gene_ID = gene_ids,
+        Gene = unlist(lapply(gene_ids, function(x) {
+            get_gene_name(x, gtf_gene)
+        })),
+        logCPM = tbl$logCPM,
+        log2FoldChange = tbl$logFC,
+        pvalue = tbl$PValue,
+        padj = if ("FDR" %in% colnames(tbl)) tbl$FDR else p.adjust(tbl$PValue, method = "BH"),
+        stringsAsFactors = FALSE
+    )
+    rownames(out) <- gene_ids
+    stat_col <- intersect(c("F", "LR"), colnames(tbl))
+    if (length(stat_col) > 0) {
+        out$stat <- tbl[[stat_col[1]]]
+    }
+    if (center) {
+        shift <- lfc_global_shift(out$log2FoldChange)
+        message(paste0("Global shift (median log2FoldChange) subtracted in log2FoldChange_centered: ", shift))
+        out$log2FoldChange_centered <- out$log2FoldChange - shift
+    }
+    add_gene_coordinates(out, out$Gene_ID, gtf_gene, after = "Gene_ID")
+}
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 75da884d..1fe60991 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -164,7 +164,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \$i| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then python3 $BINS/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff $PVAL --lfc-cutoff $LFC --input \"\${i}\" --output-sig Sig_\${i} --output-up SigUP_\${i} --output-down SigDOWN_\${i}; else touch Sig_\${i} SigUP_\${i} SigDOWN_\${i}; fi;done 2> log
     """
 }
 
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index 0efa6536..c8f819ee 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -164,7 +164,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then python3 $BINS/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff $PVAL --lfc-cutoff $LFC --input \"\${i}\" --output-sig Sig_\${i} --output-up SigUP_\${i} --output-down SigDOWN_\${i}; else touch Sig_\${i} SigUP_\${i} SigDOWN_\${i}; fi;done 2> log
     """
 }
 
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index b334ebb8..586d755a 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -90,8 +90,9 @@ rule filter_significant:
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DE', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc')
-    shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc'),
+            bins = BINS
+    shell: "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
 
 
 rule create_summary_snippet:

From 9bc3ab8e3ae292cae4c917263c0d6f03591dc915 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 8 Oct 2026 14:16:32 +0200
Subject: [PATCH 73/80] unified output and filtering across other enrichment
 analysis steps

---
 scripts/Analysis/DEU/DEXSEQ.R                 |   7 +
 scripts/Analysis/DEU/EDGER.R                  |   4 +-
 scripts/Analysis/filter_significant.py        | 146 +++++++++++-------
 ...alore-picard-star_DTU_drimseq_subsnake.smk |   5 +-
 ...imgalore-picard-star_DTU_spit_subsnake.smk |   5 +-
 workflows/dexseq_DEU.nf                       |   2 +-
 workflows/dexseq_DEU.smk                      |   5 +-
 workflows/diego_DAS.nf                        |   2 +-
 workflows/diego_DAS.smk                       |   5 +-
 workflows/drimseq_DTU.smk                     |   5 +-
 workflows/edger_DAS.nf                        |   2 +-
 workflows/edger_DAS.smk                       |   5 +-
 workflows/edger_DEU.nf                        |   2 +-
 workflows/edger_DEU.smk                       |   5 +-
 workflows/spit_DTU.smk                        |   5 +-
 15 files changed, 131 insertions(+), 74 deletions(-)

diff --git a/scripts/Analysis/DEU/DEXSEQ.R b/scripts/Analysis/DEU/DEXSEQ.R
index b66c1c8d..f235ae26 100755
--- a/scripts/Analysis/DEU/DEXSEQ.R
+++ b/scripts/Analysis/DEU/DEXSEQ.R
@@ -179,6 +179,13 @@ for (contrast in comparisons[[1]]) {
 
         toprint <- as.data.frame(dxr1)
         toprint$transcripts <- vapply(toprint$transcripts, paste, collapse = ", ", character(1L))
+        # DEXSeq names the fold change log2fold_<numerator>_<denominator>, give it a
+        # stable name so the filter can address it, the contrast is in the file name
+        lfc_col <- grep("^log2fold_", colnames(toprint))
+        if (length(lfc_col) != 1) {
+            stop(paste("DEXSeq results: expected exactly one log2fold_* column, found", length(lfc_col)))
+        }
+        colnames(toprint)[lfc_col] <- "log2FoldChange"
         toprint <- add_gene_coordinates(toprint, toprint$groupID, gtf.df, after = "groupID")
         write.table(toprint, gzfile(paste("Tables/DEU", "DEXSEQ", combi, contrast_name, "table", "results.tsv.gz", sep = "_")), sep = "\t", row.names = FALSE, quote = F)
 
diff --git a/scripts/Analysis/DEU/EDGER.R b/scripts/Analysis/DEU/EDGER.R
index 842c2508..78647e7d 100755
--- a/scripts/Analysis/DEU/EDGER.R
+++ b/scripts/Analysis/DEU/EDGER.R
@@ -253,7 +253,9 @@ for (compare in comparisons[[1]]) {
         })
         qlf$table$Gene_ID <- qlf$genes$genes
         qlf$table$ExonPos <- qlf$genes$exons
-        res <- qlf$table[, c(6, 5, 7, 1, 2, 3, 4)]
+        # edgeR reports raw PValue only, add the BH adjusted p-value the filter works on
+        qlf$table$FDR <- p.adjust(qlf$table$PValue, method = "BH")
+        res <- qlf$table[, c(6, 5, 7, 1, 2, 3, 4, 8)]
         res <- add_gene_coordinates(res, res$Gene_ID, gtf_gene, after = "Gene_ID")
         res <- as.data.frame(apply(res, 2, as.character))
 
diff --git a/scripts/Analysis/filter_significant.py b/scripts/Analysis/filter_significant.py
index 75e85eb0..3ac394fc 100755
--- a/scripts/Analysis/filter_significant.py
+++ b/scripts/Analysis/filter_significant.py
@@ -1,20 +1,29 @@
 #!/usr/bin/env python3
-"""Header-aware significant-hit filter for DE result tables.
-
-Replaces the positional Perl one-liners in the deseq2_DE/edger_DE workflows.
-Columns are located by header name, so adding or reordering annotation columns
-(Coordinates, stat, ...) cannot silently shift the tested fields.
-
-A row is kept when the adjusted p-value is strictly below --p-cutoff and the
-absolute effect size is at least --lfc-cutoff. Only finite values in the two
-required columns are evaluated; missing optional annotation columns (e.g.
-Coordinates, Gene) or an NA in an optional column such as edgeR's F do not
-discard a row. Non-numeric values in a required column are treated as malformed
-input and abort with a clear error. Header-only inputs produce gzip outputs
-containing only the header.
+"""Header-aware significant-hit filter for DE/DEU/DAS/DTU result tables.
+
+Replaces the positional Perl one-liners in the workflows. Columns are located
+by header name, so adding or reordering annotation columns (Coordinates, Gene,
+stat, ...) cannot silently shift the tested fields. Different tools name their
+columns differently (log2FoldChange/logFC/lfc, padj/FDR/adj_pvalue), so the
+caller passes the names of the table it filters.
+
+Numeric mode (--effect-column/--adjusted-p-column): a row is kept when the
+adjusted p-value is strictly below --p-cutoff and the absolute effect size is
+at least --lfc-cutoff. Flag mode (--flag-column/--flag-value): a row is kept
+when the flag column equals the given value, used for tools such as DIEGO that
+report significance categorically instead of as p-value plus effect size. Both
+modes can be combined, a row then has to satisfy all criteria.
+
+Only finite values in the tested numeric columns are evaluated; missing
+optional annotation columns or an NA in an untested column do not discard a
+row. Non-numeric values in a tested column are treated as malformed input and
+abort with a clear error. Header-only inputs produce outputs containing only
+the header. Outputs are gzip compressed when their name ends in .gz, plain text
+otherwise.
 """
 
 import argparse
+import contextlib
 import gzip
 import math
 import sys
@@ -28,6 +37,20 @@ def open_maybe_gzip(path):
     return open(path, "r", encoding="utf-8", newline="")
 
 
+def open_out(path):
+    if path.endswith(".gz"):
+        return gzip.open(path, "wt", encoding="utf-8", newline="")
+    return open(path, "w", encoding="utf-8", newline="")
+
+
+def column_index(header, colname, what):
+    if colname not in header:
+        raise ValueError(
+            "%s column %r not found in header: %s" % (what, colname, header)
+        )
+    return header.index(colname)
+
+
 def read_header(handle):
     line = handle.readline()
     if not line:
@@ -51,62 +74,77 @@ def parse_required(value, colname, lineno):
         )
 
 
-def filter_table(inpath, effect_col, adjp_col, p_cut, lfc_cut, out_sig, out_up, out_down):
-    with open_maybe_gzip(inpath) as fh:
+def filter_table(inpath, effect_col, adjp_col, p_cut, lfc_cut, flag_col, flag_value,
+                 out_sig, out_up, out_down):
+    with open_maybe_gzip(inpath) as fh, contextlib.ExitStack() as stack:
         header = read_header(fh)
-        if effect_col not in header:
-            raise ValueError(
-                "effect column %r not found in header: %s" % (effect_col, header)
-            )
-        if adjp_col not in header:
-            raise ValueError(
-                "adjusted p column %r not found in header: %s" % (adjp_col, header)
-            )
-        eidx = header.index(effect_col)
-        aidx = header.index(adjp_col)
+        eidx = aidx = fidx = None
+        if effect_col is not None:
+            eidx = column_index(header, effect_col, "effect")
+            aidx = column_index(header, adjp_col, "adjusted p")
+        if flag_col is not None:
+            fidx = column_index(header, flag_col, "flag")
         header_line = "\t".join(header) + "\n"
-        with gzip.open(out_sig, "wt", encoding="utf-8", newline="") as sig, \
-             gzip.open(out_up, "wt", encoding="utf-8", newline="") as up, \
-             gzip.open(out_down, "wt", encoding="utf-8", newline="") as down:
-            sig.write(header_line)
-            up.write(header_line)
-            down.write(header_line)
-            for lineno, line in enumerate(fh, start=2):
-                if not line.strip():
-                    continue
-                fields = line.rstrip("\n").split("\t")
-                if len(fields) != len(header):
-                    raise ValueError(
-                        "line %d: expected %d fields, got %d"
-                        % (lineno, len(header), len(fields))
-                    )
+        sig = stack.enter_context(open_out(out_sig))
+        up = stack.enter_context(open_out(out_up)) if out_up else None
+        down = stack.enter_context(open_out(out_down)) if out_down else None
+        for handle in (sig, up, down):
+            if handle is not None:
+                handle.write(header_line)
+        for lineno, line in enumerate(fh, start=2):
+            if not line.strip():
+                continue
+            fields = line.rstrip("\n").split("\t")
+            if len(fields) != len(header):
+                raise ValueError(
+                    "line %d: expected %d fields, got %d"
+                    % (lineno, len(header), len(fields))
+                )
+            if fidx is not None and fields[fidx].strip() != flag_value:
+                continue
+            lfc = None
+            if eidx is not None:
                 pval = parse_required(fields[aidx], adjp_col, lineno)
                 lfc = parse_required(fields[eidx], effect_col, lineno)
                 if pval is None or lfc is None:
                     continue
                 if not (math.isfinite(pval) and math.isfinite(lfc)):
                     continue
-                if pval < p_cut and abs(lfc) >= lfc_cut:
-                    sig.write(line)
-                    if lfc >= lfc_cut:
-                        up.write(line)
-                    if lfc <= -lfc_cut:
-                        down.write(line)
+                if not (pval < p_cut and abs(lfc) >= lfc_cut):
+                    continue
+            sig.write(line)
+            if lfc is not None:
+                if up is not None and lfc >= lfc_cut:
+                    up.write(line)
+                if down is not None and lfc <= -lfc_cut:
+                    down.write(line)
 
 
 def main(argv=None):
     parser = argparse.ArgumentParser(
         description="Filter a DE result table for significant hits by column name."
     )
-    parser.add_argument("--effect-column", required=True, help="effect size column (log2FoldChange/logFC)")
-    parser.add_argument("--adjusted-p-column", required=True, help="adjusted p-value column (padj/FDR)")
-    parser.add_argument("--p-cutoff", required=True, type=float, help="adjusted p-value cutoff (strict <)")
-    parser.add_argument("--lfc-cutoff", required=True, type=float, help="absolute log fold change cutoff (>=)")
+    parser.add_argument("--effect-column", help="effect size column (log2FoldChange/logFC/lfc)")
+    parser.add_argument("--adjusted-p-column", help="adjusted p-value column (padj/FDR/adj_pvalue)")
+    parser.add_argument("--p-cutoff", type=float, help="adjusted p-value cutoff (strict <)")
+    parser.add_argument("--lfc-cutoff", type=float, help="absolute log fold change cutoff (>=)")
+    parser.add_argument("--flag-column", help="categorical significance column (DIEGO: significant)")
+    parser.add_argument("--flag-value", default="yes", help="value the flag column has to equal")
     parser.add_argument("--input", required=True, help="input result table (plain or gzip)")
-    parser.add_argument("--output-sig", required=True, help="gzip output with all significant rows")
-    parser.add_argument("--output-up", required=True, help="gzip output with up-regulated rows")
-    parser.add_argument("--output-down", required=True, help="gzip output with down-regulated rows")
+    parser.add_argument("--output-sig", required=True, help="output with all significant rows")
+    parser.add_argument("--output-up", help="output with up-regulated rows, numeric mode only")
+    parser.add_argument("--output-down", help="output with down-regulated rows, numeric mode only")
     args = parser.parse_args(argv)
+    numeric = [args.effect_column, args.adjusted_p_column, args.p_cutoff, args.lfc_cutoff]
+    if any(v is not None for v in numeric) and any(v is None for v in numeric):
+        parser.error(
+            "--effect-column, --adjusted-p-column, --p-cutoff and --lfc-cutoff "
+            "have to be given together"
+        )
+    if args.effect_column is None and args.flag_column is None:
+        parser.error("either the numeric columns or --flag-column has to be given")
+    if args.effect_column is None and (args.output_up or args.output_down):
+        parser.error("--output-up/--output-down need --effect-column")
     try:
         filter_table(
             args.input,
@@ -114,6 +152,8 @@ def main(argv=None):
             args.adjusted_p_column,
             args.p_cutoff,
             args.lfc_cutoff,
+            args.flag_column,
+            args.flag_value,
             args.output_sig,
             args.output_up,
             args.output_down,
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index ffd3dcf4..8e53f1a1 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -466,8 +466,9 @@ rule filter_significant_drimseq:
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
 rule create_summary_snippet:
     input:  rules.run_DTU.output.res_t,
             rules.run_DTU.output.res_g,
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index 26d803c1..93d3442b 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -460,8 +460,9 @@ rule filter_significant_spit:
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
 rule create_summary_snippet:
     input:  rules.run_DTU.output.res_t,
             rules.run_DTU.output.res_g,
diff --git a/workflows/dexseq_DEU.nf b/workflows/dexseq_DEU.nf
index 7c477ac9..fce3d95f 100644
--- a/workflows/dexseq_DEU.nf
+++ b/workflows/dexseq_DEU.nf
@@ -201,7 +201,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then python3 $BINS/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff $PVAL --lfc-cutoff $LFC --input \"\${i}\" --output-sig Sig_\${i} --output-up SigUP_\${i} --output-down SigDOWN_\${i}; else touch Sig_\${i} SigUP_\${i} SigDOWN_\${i}; fi;done 2> log
     """
 }
 
diff --git a/workflows/dexseq_DEU.smk b/workflows/dexseq_DEU.smk
index 9b3ce5ad..4cd28290 100644
--- a/workflows/dexseq_DEU.smk
+++ b/workflows/dexseq_DEU.smk
@@ -99,8 +99,9 @@ rule filter_significant:
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DEU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] <= -{params.lfc_cut} ||$F[9] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[9] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[9] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
 
 rule create_summary_snippet:
     input:  rules.run_dexseq.output.plot,
diff --git a/workflows/diego_DAS.nf b/workflows/diego_DAS.nf
index cd97a008..4ee1adc5 100644
--- a/workflows/diego_DAS.nf
+++ b/workflows/diego_DAS.nf
@@ -206,7 +206,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; arr=($tabs); for i in \${!arr[@]}; do a=\${arr[\$i]}; fn=\${a##*/}; if [[ -s \"\$a\" ]];then cat \$a|head -n1 > Sig_\$a; cat \$a| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[10]);if (\$F[10] eq \"yes\") {print}' >> Sig_\$a &>> log; else touch \${orr[\$i]}; fi; done
+    set +o pipefail; arr=($tabs); for i in \${!arr[@]}; do a=\${arr[\$i]}; if [[ -s \"\$a\" ]];then python3 $BINS/Analysis/filter_significant.py --flag-column significant --flag-value yes --input \"\$a\" --output-sig Sig_\$a; else touch Sig_\$a; fi; done 2> log
     """
 }
 
diff --git a/workflows/diego_DAS.smk b/workflows/diego_DAS.smk
index e8497712..dec4409c 100644
--- a/workflows/diego_DAS.smk
+++ b/workflows/diego_DAS.smk
@@ -99,8 +99,9 @@ rule filter_significant:
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DAS', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc')
-    shell: "set +o pipefail; arr=({input.csv}); orr=({output.sig}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then cat $a|head -n1 > \"${{orr[$i]}}\"; cat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[10]);if ($F[10] eq \"yes\") {{print}}' >> \"${{orr[$i]}}\" &>> {log}; else touch \"${{orr[$i]}}\"; fi; done"
+            lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc'),
+            bins = BINS
+    shell: "set +o pipefail; arr=({input.csv}); orr=({output.sig}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --flag-column significant --flag-value yes --input \"$a\" --output-sig \"${{orr[$i]}}\"; else touch \"${{orr[$i]}}\"; fi; done 2> {log}"
 
 
 rule convertPDF:
diff --git a/workflows/drimseq_DTU.smk b/workflows/drimseq_DTU.smk
index f9b8cfd1..4fc06da5 100644
--- a/workflows/drimseq_DTU.smk
+++ b/workflows/drimseq_DTU.smk
@@ -74,8 +74,9 @@ rule filter_significant_drimseq:
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
 
 rule create_summary_snippet:
     input:  rules.run_DTU.output.res_t,
diff --git a/workflows/edger_DAS.nf b/workflows/edger_DAS.nf
index ffafedfc..b322a552 100644
--- a/workflows/edger_DAS.nf
+++ b/workflows/edger_DAS.nf
@@ -158,7 +158,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then python3 $BINS/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff $PVAL --lfc-cutoff $LFC --input \"\${i}\" --output-sig Sig_\${i} --output-up SigUP_\${i} --output-down SigDOWN_\${i}; else touch Sig_\${i} SigUP_\${i} SigDOWN_\${i}; fi;done 2> log
     """
 }
 
diff --git a/workflows/edger_DAS.smk b/workflows/edger_DAS.smk
index dbddabfe..0761ec9e 100644
--- a/workflows/edger_DAS.smk
+++ b/workflows/edger_DAS.smk
@@ -83,8 +83,9 @@ rule filter_significant_edger:
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DAS', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc')
-    shell: "set +o pipefail; arr=({input.sort}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] <= -{params.lfc_cut} ||$F[6] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[6] || !$F[3]);if ($F[3] < {params.pv_cut} && ($F[6] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc'),
+            bins = BINS
+    shell: "set +o pipefail; arr=({input.sort}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
 
 rule create_summary_snippet:
     input:  rules.themall.input.allM,
diff --git a/workflows/edger_DEU.nf b/workflows/edger_DEU.nf
index 4bcc3123..466bd670 100644
--- a/workflows/edger_DEU.nf
+++ b/workflows/edger_DEU.nf
@@ -157,7 +157,7 @@ process filter_significant{
 
     script:  
     """
-    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then zcat \${i}| head -n1 |gzip > Sig_\${i};cp -f Sig_\${i} SigUP_\${i}; cp -f Sig_\${i} SigDOWN_\${i}; zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC ||\$F[3] >= $LFC) ){{print}}' |gzip >> Sig_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] >= $LFC) ){{print}}' |gzip >> SigUP_\${i} && zcat \${i}| tail -n+2 |grep -v -w 'NA'|perl -F'\\t' -wlane 'next if (!\$F[6] || !\$F[3]);if (\$F[6] < $PVAL && (\$F[3] <= -$LFC) ){{print}}' |gzip >> SigDOWN_\${i}; else touch Sig_\${i} SigUP\${i} SigDOWN_\${i}; fi;done 2> log
+    set +o pipefail; for i in $tabs; do if [[ -s \"\${i}\" ]];then python3 $BINS/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff $PVAL --lfc-cutoff $LFC --input \"\${i}\" --output-sig Sig_\${i} --output-up SigUP_\${i} --output-down SigDOWN_\${i}; else touch Sig_\${i} SigUP_\${i} SigDOWN_\${i}; fi;done 2> log
     """
 }
 
diff --git a/workflows/edger_DEU.smk b/workflows/edger_DEU.smk
index df4459ae..d5b9a3e8 100644
--- a/workflows/edger_DEU.smk
+++ b/workflows/edger_DEU.smk
@@ -82,8 +82,9 @@ rule filter_significant:
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DEU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrt[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrr[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut} ||$F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[3] || !$F[6]);if ($F[6] < {params.pv_cut} && ($F[3] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
 
 
 rule create_summary_snippet:
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
index d15de3dd..3871b00f 100644
--- a/workflows/spit_DTU.smk
+++ b/workflows/spit_DTU.smk
@@ -68,8 +68,9 @@ rule filter_significant_spit:
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
-            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
-    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orr[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orrd[$i]}}\"; cp \"${{orr[$i]}}\" \"${{orru[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orr[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orru[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; fn=\"${{a##*/}}\"; if [[ -s \"$a\" ]];then zcat $a| head -n1 |gzip > \"${{orrt[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\"; cp \"${{orrt[$i]}}\" \"${{orrtu[$i]}}\"; zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrt[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtu[$i]}}\" && zcat $a| tail -n+2 |grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[2] || !$F[1]);if ($F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut}) ){{print}}' |gzip >> \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
+            lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
+            bins = BINS
+    shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
 
 rule create_summary_snippet:
     input:  rules.run_DTU.output.res_t,

From 0d30403f3c66c5300a7055e8a01fd0941077b00e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 8 Oct 2026 20:16:55 +0200
Subject: [PATCH 74/80] Major fix in nextflow sample handling for R1/R2,
 unified across all recipes

---
 ...imgalore-picard-star_DTU_dexseq_subflow.nf | 34 +++++++++++++-
 ...mgalore-picard-star_DTU_drimseq_subflow.nf | 34 +++++++++++++-
 ...trimgalore-picard-star_DTU_spit_subflow.nf | 34 +++++++++++++-
 ...-picard-star_FUSIONS_starfusion_subflow.nf | 36 ++++++++++++--
 .../Test_fastqc-bbduk-picard-bwa_subflow.nf   | 42 +++++++++++++++--
 ...Test_fastqc-bbduk-picard-rustar_subflow.nf | 47 ++++++++++++++++---
 .../Test_fastqc-bbduk-picard-star_subflow.nf  | 47 ++++++++++++++++---
 ...Test_fastqc-cutadapt-picard-bwa_subflow.nf | 42 +++++++++++++++--
 ...t_fastqc-cutadapt-picard-rustar_subflow.nf | 47 ++++++++++++++++---
 ...est_fastqc-cutadapt-picard-star_subflow.nf | 47 ++++++++++++++++---
 ...st_fastqc-trimgalore-picard-bwa_subflow.nf | 42 +++++++++++++++--
 ...fastqc-trimgalore-picard-rustar_subflow.nf | 47 ++++++++++++++++---
 ...t_fastqc-trimgalore-picard-star_subflow.nf | 47 ++++++++++++++++---
 workflows/bbduk.nf                            |  5 +-
 workflows/bwa.nf                              |  5 +-
 workflows/bwa2.nf                             |  5 +-
 workflows/bwameth.nf                          |  5 +-
 workflows/countreads.nf                       | 27 ++++++-----
 workflows/cutadapt.nf                         |  5 +-
 workflows/deseq2_DE.nf                        |  4 +-
 workflows/dexseq_DEU.nf                       |  4 +-
 workflows/dexseq_DTU.nf                       |  2 +-
 workflows/drimseq_DTU.nf                      |  2 +-
 workflows/edger_DAS.nf                        |  4 +-
 workflows/edger_DE.nf                         |  4 +-
 workflows/edger_DEU.nf                        |  4 +-
 workflows/fastp.nf                            |  5 +-
 workflows/fastqc_dedup.nf                     |  2 +-
 workflows/fastqc_dedup_trim.nf                |  2 +-
 workflows/fastqc_trim.nf                      |  2 +-
 workflows/fgumi.nf                            | 11 +++--
 workflows/fgumi_dedup.nf                      |  2 +-
 workflows/header.nf                           | 42 ++++++++++++++++-
 workflows/hisat2.nf                           |  5 +-
 workflows/kallisto.nf                         |  6 +--
 workflows/minimap.nf                          |  5 +-
 workflows/piscem.nf                           |  5 +-
 workflows/rammap.nf                           |  5 +-
 workflows/rastqc_dedup.nf                     |  2 +-
 workflows/rastqc_dedup_trim.nf                |  2 +-
 workflows/rastqc_trim.nf                      |  2 +-
 workflows/rustar.nf                           | 10 ++--
 workflows/salmon.nf                           |  6 +--
 workflows/salmonalign.nf                      |  5 +-
 workflows/segemehl.nf                         |  5 +-
 workflows/segemehl3.nf                        |  5 +-
 workflows/segemehl3_bisulfite.nf              |  5 +-
 workflows/segemehl_bisulfite.nf               |  5 +-
 workflows/simpleaf.nf                         |  4 +-
 workflows/simulatetrim.nf                     |  5 +-
 workflows/spit_DTU.nf                         |  2 +-
 workflows/star.nf                             | 10 ++--
 workflows/starfusion.nf                       |  4 +-
 workflows/trimgalore.nf                       |  5 +-
 workflows/umicollapse.nf                      | 19 ++++----
 workflows/umicollapse_dedup.nf                |  5 +-
 workflows/umitools.nf                         | 28 ++++++-----
 57 files changed, 664 insertions(+), 179 deletions(-)

diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
index c48d5033..fe936587 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subflow.nf
@@ -51,7 +51,7 @@ params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -59,6 +59,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
@@ -253,7 +283,7 @@ workflow DTU{
     take: collection
     main:
     TRIMSAMPLES = params.gLONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
     annofile = Channel.fromPath(params.gDTUANNO)
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
index 7d0ab619..f27340dd 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subflow.nf
@@ -51,7 +51,7 @@ params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -59,6 +59,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
@@ -254,7 +284,7 @@ workflow DTU{
     take: collection
     main:
     TRIMSAMPLES = params.gLONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
     annofile = Channel.fromPath(params.gDTUANNO)
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
index ed36b560..958133c9 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subflow.nf
@@ -51,7 +51,7 @@ params.gCOUNTENV = 'salmon'
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -59,6 +59,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process salmon_quant{
     conda "<REPO>/envs/${params.gCOUNTENV}"+".yaml"
@@ -252,7 +282,7 @@ workflow DTU{
     take: collection
     main:
     TRIMSAMPLES = params.gLONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
     annofile = Channel.fromPath(params.gDTUANNO)
diff --git a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
index cbd7a4ec..98edf83d 100644
--- a/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
+++ b/tests/golden/config_FUSIONS/nf/allconditions_fastqc-trimgalore-picard-star_FUSIONS_starfusion_subflow.nf
@@ -40,7 +40,7 @@ params.gFUSFASTQ = (get_always('starfusion_params_FASTQ') ?: '').toString().toLo
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -48,6 +48,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process starfusion{
     conda "<REPO>/envs/${params.gFUSENV}"+".yaml"
@@ -94,7 +124,7 @@ process starfusion_fastq{
     ref = fls[0]
     anno = fls[1]
     if (params.gPAIRED == 'paired'){
-        rs = fls[2..3].sort{ it.getName() }
+        rs = sort_reads(fls[2..3])
         reads = "--left_fq "+rs[0]+" --right_fq "+rs[1]
         fn = file(rs[0]).getSimpleName().replaceAll(/_R[12]_trimmed/, "")
     } else{
@@ -115,7 +145,7 @@ workflow FUSIONS{
     if (params.gFUSFASTQ){
         if (params.gPAIRED == 'paired'){
             TRIMSAMPLES = params.gLONGSAMPLES.collect{
-                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${params.gCOMBO}/"+element+"_{R1,R2}_trimmed.fastq.gz"
             }
         } else{
             TRIMSAMPLES = params.gLONGSAMPLES.collect{
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
index c1b60762..3b140ef3 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-bwa_subflow.nf
@@ -55,7 +55,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -63,6 +63,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -193,8 +223,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -330,8 +361,9 @@ process bwa_mapping{
     script:
     idx = reads[0]
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
index f12dbd57..ecbcfc01 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-rustar_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -338,8 +369,9 @@ process rustar_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -366,9 +398,10 @@ process rustar_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            rds = sort_reads(reads[1..2])
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
index 074b1263..b54480be 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-bbduk-picard-star_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -338,8 +369,9 @@ process star_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -359,6 +391,7 @@ process star_mapping{
             """
         }
         else{
+            rds = sort_reads(reads[1..2])
             if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
             }else if (params.gSTRANDED == 'rf'){
@@ -366,9 +399,9 @@ process star_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
index 5bf6bd57..c802ba45 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-bwa_subflow.nf
@@ -55,7 +55,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -63,6 +63,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -193,8 +223,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -330,8 +361,9 @@ process bwa_mapping{
     script:
     idx = reads[0]
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
index 7c8c0c9c..8aea7c38 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-rustar_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -338,8 +369,9 @@ process rustar_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -366,9 +398,10 @@ process rustar_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            rds = sort_reads(reads[1..2])
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
index a88adb63..a7dd8500 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-cutadapt-picard-star_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
@@ -338,8 +369,9 @@ process star_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -359,6 +391,7 @@ process star_mapping{
             """
         }
         else{
+            rds = sort_reads(reads[1..2])
             if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
             }else if (params.gSTRANDED == 'rf'){
@@ -366,9 +399,9 @@ process star_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
index 24969530..432ce0a0 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-bwa_subflow.nf
@@ -55,7 +55,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -63,6 +63,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -193,8 +223,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         """
         ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
@@ -325,8 +356,9 @@ process bwa_mapping{
     script:
     idx = reads[0]
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
index 39e0c5f9..f18e5841 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-rustar_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         """
         ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
@@ -333,8 +364,9 @@ process rustar_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -361,9 +393,10 @@ process rustar_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            rds = sort_reads(reads[1..2])
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
index c5186453..b0a2c073 100644
--- a/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
+++ b/tests/golden/config_Test/nf/Test_fastqc-trimgalore-picard-star_subflow.nf
@@ -54,7 +54,7 @@ params.gMQCPARAMS = get_always('fastqc_params_MULTI') ?: ''
 params.gRSAMPLES = {
 if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     return params.gSAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     return params.gSAMPLES.collect{
@@ -62,6 +62,36 @@ if (params.gPAIRED == 'paired' || params.gPAIRED == 'singlecell'){
     }
 }
 }()
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
 
 process qc_raw{
     conda "<REPO>/envs/${params.gQCENV}"+".yaml"
@@ -192,8 +222,9 @@ process trim{
     path "*trimming_report.txt", emit: rep
     script:
     if (params.gPAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         """
         ${params.gTRIMBIN} --cores ${task.cpus} --paired --gzip ${params.gTRIMPARAMS} $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
@@ -333,8 +364,9 @@ process star_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (params.gPAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -354,6 +386,7 @@ process star_mapping{
             """
         }
         else{
+            rds = sort_reads(reads[1..2])
             if (params.gSTRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
             }else if (params.gSTRANDED == 'rf'){
@@ -361,9 +394,9 @@ process star_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${params.gCONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (params.gMAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/workflows/bbduk.nf b/workflows/bbduk.nf
index 6dcfb261..fc4e0743 100644
--- a/workflows/bbduk.nf
+++ b/workflows/bbduk.nf
@@ -28,8 +28,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
diff --git a/workflows/bwa.nf b/workflows/bwa.nf
index 9db047a6..fc8aa40f 100644
--- a/workflows/bwa.nf
+++ b/workflows/bwa.nf
@@ -87,8 +87,9 @@ process bwa_mapping{
     script:
     idx = reads[0]
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/bwa2.nf b/workflows/bwa2.nf
index e7ccd535..04e3e403 100644
--- a/workflows/bwa2.nf
+++ b/workflows/bwa2.nf
@@ -87,8 +87,9 @@ process bwa2_mapping{
     script:
     idx = reads[0]
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/bwameth.nf b/workflows/bwameth.nf
index ffe845d7..bfaaf07e 100644
--- a/workflows/bwameth.nf
+++ b/workflows/bwameth.nf
@@ -89,8 +89,9 @@ process bwameth_mapping{
     script:
     idx = reads[0]
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/countreads.nf b/workflows/countreads.nf
index e800a5d7..4b319cac 100644
--- a/workflows/countreads.nf
+++ b/workflows/countreads.nf
@@ -37,8 +37,9 @@ process count_fastq{
 
     script:    
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1\E/,"")    
         oo = fn+"_raw_R1_fq.count"        
         ft = file(r2).getSimpleName().replaceAll(/\Q_R2\E/,"")    
@@ -80,8 +81,9 @@ process count_trimmed_fastq{
 
     script:    
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")    
         oo = fn+"_trimmed_R1_fq.count"        
         ft = file(r2).getSimpleName().replaceAll(/\Q_R2_trimmed\E/,"")    
@@ -123,8 +125,9 @@ process count_dedup_fastq{
 
     script:    
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_dedup\E/,"")    
         oo = fn+"_dedup_R1_fq.count"        
         ft = file(r2).getSimpleName().replaceAll(/\Q_R2_dedup\E/,"")    
@@ -254,9 +257,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DEREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
@@ -295,13 +298,13 @@ workflow COUNTING{
 
     if (PAIRED == 'paired'){
         RAWSAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
         TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
         DEDUPSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../DEDUP_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../DEDUP_FASTQ/${COMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
     }else{
         RAWSAMPLES = SAMPLES.collect{
@@ -337,7 +340,7 @@ workflow COUNTING{
     }        
     count_mappers(mapsamples_ch.collate(1))
     featurecount(annofile.combine(mapsamples_ch.collate(1)))
-    prepare_count_table(featurecount.out.fc_cts.collate(1))
+    prepare_count_table(featurecount.out.fc_cts.collect())
     summarize_counts(count_fastq.out.fq_cts.concat(count_dedup_fastq.out.fqd_cts.concat(count_trimmed_fastq.out.fqt_cts.concat(count_mappers.out.map_cts))).collect())
 
     emit:
diff --git a/workflows/cutadapt.nf b/workflows/cutadapt.nf
index c0f3c50d..6c8f2fa2 100644
--- a/workflows/cutadapt.nf
+++ b/workflows/cutadapt.nf
@@ -28,8 +28,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
diff --git a/workflows/deseq2_DE.nf b/workflows/deseq2_DE.nf
index 1fe60991..680c7683 100644
--- a/workflows/deseq2_DE.nf
+++ b/workflows/deseq2_DE.nf
@@ -97,9 +97,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DEREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
diff --git a/workflows/dexseq_DEU.nf b/workflows/dexseq_DEU.nf
index fce3d95f..99f33b82 100644
--- a/workflows/dexseq_DEU.nf
+++ b/workflows/dexseq_DEU.nf
@@ -132,9 +132,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DEUREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DEUREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
diff --git a/workflows/dexseq_DTU.nf b/workflows/dexseq_DTU.nf
index 5bfb8bcc..bb81b9af 100644
--- a/workflows/dexseq_DTU.nf
+++ b/workflows/dexseq_DTU.nf
@@ -147,7 +147,7 @@ workflow DTU{
     main:
     
     TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
 
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
diff --git a/workflows/drimseq_DTU.nf b/workflows/drimseq_DTU.nf
index 0beb3a86..3fea7b91 100644
--- a/workflows/drimseq_DTU.nf
+++ b/workflows/drimseq_DTU.nf
@@ -148,7 +148,7 @@ workflow DTU{
     main:
     
     TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
 
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
diff --git a/workflows/edger_DAS.nf b/workflows/edger_DAS.nf
index b322a552..c9c963d3 100644
--- a/workflows/edger_DAS.nf
+++ b/workflows/edger_DAS.nf
@@ -93,9 +93,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DASREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DASREPS --ids -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --ids --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
diff --git a/workflows/edger_DE.nf b/workflows/edger_DE.nf
index c8f819ee..d95717cb 100644
--- a/workflows/edger_DE.nf
+++ b/workflows/edger_DE.nf
@@ -97,9 +97,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DEREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DEREPS -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
diff --git a/workflows/edger_DEU.nf b/workflows/edger_DEU.nf
index 466bd670..aed0bfd3 100644
--- a/workflows/edger_DEU.nf
+++ b/workflows/edger_DEU.nf
@@ -93,9 +93,9 @@ process prepare_count_table{
     path "log", emit: log
 
     script:
+    repargs = rep_args(DEUREPS, reps)
     """
-    reps_csv=\$(for f in $reps; do basename "\$f"; done | paste -sd, -)
-    ${BINS}/Analysis/build_count_table.py $DEUREPS --ids -r \$reps_csv --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
+    ${BINS}/Analysis/build_count_table.py $repargs --ids --table COUNTS.gz --anno ANNOTATION.gz --nextflow 2> log
     """
 }
 
diff --git a/workflows/fastp.nf b/workflows/fastp.nf
index bd7eab22..2d78ae72 100644
--- a/workflows/fastp.nf
+++ b/workflows/fastp.nf
@@ -28,8 +28,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         o = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         p = file(r2).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimmed.fastq.gz"
         r = file(r1).getSimpleName().replaceAll(/_dedup/,"").replaceAll(/.fastq.gz/,"")+"_trimming_report.txt"
diff --git a/workflows/fastqc_dedup.nf b/workflows/fastqc_dedup.nf
index 85665236..b7c8fde3 100644
--- a/workflows/fastqc_dedup.nf
+++ b/workflows/fastqc_dedup.nf
@@ -36,7 +36,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/fastqc_dedup_trim.nf b/workflows/fastqc_dedup_trim.nf
index 2e53b7f2..8d57a7db 100644
--- a/workflows/fastqc_dedup_trim.nf
+++ b/workflows/fastqc_dedup_trim.nf
@@ -36,7 +36,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/fastqc_trim.nf b/workflows/fastqc_trim.nf
index badcea20..0069b4ff 100644
--- a/workflows/fastqc_trim.nf
+++ b/workflows/fastqc_trim.nf
@@ -36,7 +36,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/fgumi.nf b/workflows/fgumi.nf
index aaade354..856ebf8c 100644
--- a/workflows/fgumi.nf
+++ b/workflows/fgumi.nf
@@ -27,12 +27,13 @@ process extract_fq{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = samples[0]
-        r2 = samples[1]
-        sn = samples[0].getSimpleName().replace("_R1","")
+        reads = sort_reads(samples)
+        r1 = reads[0]
+        r2 = reads[1]
+        sn = reads[0].getSimpleName().replace("_R1","")
         ubam = sn+"_fgumi_extract.bam"
-        outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
-        outf2 = samples[1].getSimpleName()+"_dedup.fastq.gz"
+        outf = reads[0].getSimpleName()+"_dedup.fastq.gz"
+        outf2 = reads[1].getSimpleName()+"_dedup.fastq.gz"
         """
             mkdir -p tmp && $DEDUPBIN extract $EXTRACTPARAMS --inputs $r1 $r2 --sample $sn --library $sn --output $ubam > ex.log 2>&1 && samtools fastq -n -1 $outf -2 $outf2 -0 /dev/null -s /dev/null $ubam >> ex.log 2>&1
         """
diff --git a/workflows/fgumi_dedup.nf b/workflows/fgumi_dedup.nf
index 24427f87..8b47eefa 100644
--- a/workflows/fgumi_dedup.nf
+++ b/workflows/fgumi_dedup.nf
@@ -70,7 +70,7 @@ workflow DEDUPBAM{
         def key = n
             .replaceFirst(/_fgumi_extract\.bam$/, '')
             .replaceFirst(/_extracted\.bam$/, '')
-            .replaceFirst(/_R1$/, '')
+            .replaceFirst(/_R[12]$/, '')
         tuple(key, u)
     }
     paired_ch = mapped_ch.combine(ubam_ch, by: 0).map { key, mb, ub -> tuple(key, mb, ub) }
diff --git a/workflows/header.nf b/workflows/header.nf
index 77d1a2b5..fedff093 100644
--- a/workflows/header.nf
+++ b/workflows/header.nf
@@ -15,6 +15,46 @@ def get_always(parameter){
     return params.containsKey(parameter) ? params[parameter] : null
 }
 
+//Channel element order is arrival order, not read order, so R1/R2 of a collated pair must
+//never be taken as [0]/[1] directly. Sorting by file name puts _R1 before _R2 deterministically.
+def sort_reads(rds){
+    def rdslist = (rds instanceof Collection) ? rds.toList() : [rds]
+    return rdslist.toSorted{ a, b -> a.toString().split('/')[-1] <=> b.toString().split('/')[-1] }
+}
+
+//build_count_table.py zips the '-r' list positionally with '-c'/'-t'/'-b', so the replicate
+//order must always follow the config derived REPS list and must never be taken from the
+//order in which staged files arrive on a channel. This rewrites the '-r' list in place with
+//the names of the staged files, keeping the configured order, and aborts on any mismatch.
+def rep_basename(f){
+    return f.toString().split('/')[-1]
+}
+
+def rep_key(f){
+    return rep_basename(f).replaceFirst(/\.counts\.gz$/, '').replaceFirst(/_dedup$/, '')
+}
+
+def rep_args(repsargs, staged){
+    def mt = (repsargs =~ /(^|\s)-r\s+(\S+)/)
+    if (!mt.find()){
+        throw new Exception("rep_args: no '-r' list found in REPS arguments '"+repsargs+"'")
+    }
+    def have = [:]
+    def stagedlist = (staged instanceof Collection) ? staged.toList() : [staged]
+    stagedlist.each{ f -> have[rep_key(f)] = rep_basename(f) }
+    def ordered = mt.group(2).split(',').collect{ w ->
+        def k = rep_key(w.trim())
+        if (!have.containsKey(k)){
+            throw new Exception("rep_args: no staged count file for replicate '"+w.trim()+"' (key '"+k+"'), staged keys: "+have.keySet())
+        }
+        return have[k]
+    }
+    if (ordered.size() != stagedlist.size()){
+        throw new Exception("rep_args: "+stagedlist.size()+" staged count files but "+ordered.size()+" replicates in REPS arguments '"+repsargs+"'")
+    }
+    return repsargs.replaceFirst(/(^|\s)-r\s+\S+/, '$1-r '+ordered.join(','))
+}
+
 //Params from CL
 REFERENCE = "${workflow.workDir}/../"+get_always('REFERENCE')
 REFDIR = "${workflow.workDir}/../"+get_always('REFDIR')
@@ -38,7 +78,7 @@ dummy = Channel.fromPath("${workflow.workDir}/../LOGS/MONSDA.log")
 //SAMPLE CHANNELS
 if (PAIRED == 'paired' || PAIRED == 'singlecell'){
     RSAMPLES = SAMPLES.collect{
-        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+        element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
     }
 }else{
     RSAMPLES=SAMPLES.collect{
diff --git a/workflows/hisat2.nf b/workflows/hisat2.nf
index 63a98f41..1d0ecb01 100644
--- a/workflows/hisat2.nf
+++ b/workflows/hisat2.nf
@@ -93,6 +93,7 @@ process hisat2_mapping{
     
     idx = reads[0]
     if (PAIRED == 'paired'){
+        rds = sort_reads(reads[1..2])
         if (STRANDED == 'fr'){
             stranded = '--rna-strandness FR --fr'
         }else if (STRANDED == 'rf'){
@@ -103,8 +104,8 @@ process hisat2_mapping{
             stranded = ''
         }
 
-        r1 = reads[1]
-        r2 = reads[2]
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         pf = fn+"_mapped.sam"
         ufo = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/kallisto.nf b/workflows/kallisto.nf
index 888c7c96..4d975a7a 100644
--- a/workflows/kallisto.nf
+++ b/workflows/kallisto.nf
@@ -36,7 +36,7 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        rs = reads[0..1].sort{ it.getName() }
+        rs = sort_reads(reads[0..1])
         r1 = rs[0]
         r2 = rs[1]
         a="Trimming_report.txt"
@@ -121,7 +121,7 @@ process kallisto_quant{
         }else{
             stranded = ''
         }
-        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        rs = sort_reads(reads[1..2])
         r1 = rs[0]
         r2 = rs[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
@@ -162,7 +162,7 @@ workflow COUNTING{
 
     if (PAIRED == 'paired'){
         TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}_trimmed.fastq.gz"
         }
     } else{
         TRIMSAMPLES = LONGSAMPLES.collect{
diff --git a/workflows/minimap.nf b/workflows/minimap.nf
index 59289db3..e57465c8 100644
--- a/workflows/minimap.nf
+++ b/workflows/minimap.nf
@@ -86,8 +86,9 @@ process minimap_mapping{
     idxfile = reads[0]
     idx = idxfile.getName()
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/piscem.nf b/workflows/piscem.nf
index a471caab..ed240d72 100644
--- a/workflows/piscem.nf
+++ b/workflows/piscem.nf
@@ -78,8 +78,9 @@ process piscem_mapping{
 
     script:
     idxdir = reads[0]
-    r1 = reads[1]
-    r2 = reads[2]
+    rds = sort_reads(reads[1..2])
+    r1 = rds[0]
+    r2 = rds[1]
     fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
     of = fn+"_map"
     lf = "piscem_"+fn+".log"
diff --git a/workflows/rammap.nf b/workflows/rammap.nf
index 4ea7b7bf..1e4cf518 100644
--- a/workflows/rammap.nf
+++ b/workflows/rammap.nf
@@ -69,8 +69,9 @@ process rammap_mapping{
     idxfile = reads[0]
     idx = idxfile.getName()
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/rastqc_dedup.nf b/workflows/rastqc_dedup.nf
index 4dfdd419..cc9c8dbd 100644
--- a/workflows/rastqc_dedup.nf
+++ b/workflows/rastqc_dedup.nf
@@ -42,7 +42,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/rastqc_dedup_trim.nf b/workflows/rastqc_dedup_trim.nf
index 19d0b622..6af94873 100644
--- a/workflows/rastqc_dedup_trim.nf
+++ b/workflows/rastqc_dedup_trim.nf
@@ -42,7 +42,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/rastqc_trim.nf b/workflows/rastqc_trim.nf
index 545bb538..76ddddc3 100644
--- a/workflows/rastqc_trim.nf
+++ b/workflows/rastqc_trim.nf
@@ -42,7 +42,7 @@ workflow QC_RAW{
     //SAMPLE CHANNELS
     if (PAIRED == 'paired'){
         SAMPLES = SAMPLES.collect{
-            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R2,R1}.*fastq.gz"
+            element -> return "${workflow.workDir}/../FASTQ/"+element+"_{R1,R2}.*fastq.gz"
         }
     }else{
         SAMPLES=SAMPLES.collect{
diff --git a/workflows/rustar.nf b/workflows/rustar.nf
index b15427ad..b5696276 100644
--- a/workflows/rustar.nf
+++ b/workflows/rustar.nf
@@ -93,8 +93,9 @@ process rustar_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -121,9 +122,10 @@ process rustar_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            rds = sort_reads(reads[1..2])
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (MAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/workflows/salmon.nf b/workflows/salmon.nf
index a1ec8b84..953ba7a8 100644
--- a/workflows/salmon.nf
+++ b/workflows/salmon.nf
@@ -38,7 +38,7 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        rs = reads[0..1].sort{ it.getName() }
+        rs = sort_reads(reads[0..1])
         r1 = rs[0]
         r2 = rs[1]
         a="Trimming_report.txt"
@@ -122,7 +122,7 @@ process salmon_quant{
         }else{
             stranded = '-l IU'
         }
-        rs = reads[1..2].sort { a,b -> a[0] <=> b[0] == 0 ? (a[1..-1] as int) <=> (b[1..-1] as int) : a[0] <=> b[0] }
+        rs = sort_reads(reads[1..2])
         r1 = rs[0]
         r2 = rs[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
@@ -212,7 +212,7 @@ workflow COUNTING{
 
         if (PAIRED == 'paired'){
             TRIMSAMPLES = LONGSAMPLES.collect{
-                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}_trimmed.fastq.gz"
             }
         } else{
             TRIMSAMPLES = LONGSAMPLES.collect{
diff --git a/workflows/salmonalign.nf b/workflows/salmonalign.nf
index 79850a90..5e5f8e33 100644
--- a/workflows/salmonalign.nf
+++ b/workflows/salmonalign.nf
@@ -71,6 +71,7 @@ process salmonalign_mapping{
     idxfile = reads[0]
     idx = idxfile.getName()
     if (PAIRED == 'paired'){
+        rds = sort_reads(reads[1..2])
         if (STRANDED == 'fr' || STRANDED == 'ISF'){
             stranded = '-l ISF'
         }else if (STRANDED == 'rf' || STRANDED == 'ISR'){
@@ -78,8 +79,8 @@ process salmonalign_mapping{
         }else{
             stranded = '-l IU'
         }
-        r1 = reads[1]
-        r2 = reads[2]
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/segemehl.nf b/workflows/segemehl.nf
index 23821e6f..94bc508b 100644
--- a/workflows/segemehl.nf
+++ b/workflows/segemehl.nf
@@ -88,8 +88,9 @@ process segemehl_mapping{
     idx = idxfile.getName()
 
     if (PAIRED == 'paired'){
-        r1 = reads[2]
-        r2 = reads[3]
+        rds = sort_reads(reads[2..3])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/segemehl3.nf b/workflows/segemehl3.nf
index 9082c042..53dbb20d 100644
--- a/workflows/segemehl3.nf
+++ b/workflows/segemehl3.nf
@@ -92,8 +92,9 @@ process segemehl3_mapping{
     idx = idxfile.getName()
 
     if (PAIRED == 'paired'){
-        r1 = reads[2]
-        r2 = reads[3]
+        rds = sort_reads(reads[2..3])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/segemehl3_bisulfite.nf b/workflows/segemehl3_bisulfite.nf
index 20b89a64..098f4842 100644
--- a/workflows/segemehl3_bisulfite.nf
+++ b/workflows/segemehl3_bisulfite.nf
@@ -98,8 +98,9 @@ process segemehl3_mapping{
     idx2 = idxfile2.getName()
 
     if (PAIRED == 'paired'){
-        r1 = reads[3]
-        r2 = reads[4]
+        rds = sort_reads(reads[3..4])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/segemehl_bisulfite.nf b/workflows/segemehl_bisulfite.nf
index 33823548..eb583cbe 100644
--- a/workflows/segemehl_bisulfite.nf
+++ b/workflows/segemehl_bisulfite.nf
@@ -98,8 +98,9 @@ process segemehl_mapping{
     idx2 = idxfile2.getName()
 
     if (PAIRED == 'paired'){
-        r1 = reads[3]
-        r2 = reads[4]
+        rds = sort_reads(reads[3..4])
+        r1 = rds[0]
+        r2 = rds[1]
         fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
         pf = fn+"_mapped.sam.gz"
         uf1 = fn+"_R1_unmapped.fastq.gz"
diff --git a/workflows/simpleaf.nf b/workflows/simpleaf.nf
index b4c0095e..88ddccd1 100644
--- a/workflows/simpleaf.nf
+++ b/workflows/simpleaf.nf
@@ -65,7 +65,7 @@ process simpleaf_quant{
 
     script:
     idx = reads[0]
-    rs = reads[1..2].sort()
+    rs = sort_reads(reads[1..2])
     r1 = rs[0]
     r2 = rs[1]
     fn = file(r1).getSimpleName().replaceAll(/\Q_R1_trimmed\E/,"")
@@ -84,7 +84,7 @@ workflow COUNTING{
     checkidx = file(COUNTUIDX)
 
     TRIMSAMPLES = LONGSAMPLES.collect{
-        element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+        element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}_trimmed.fastq.gz"
     }
 
     trimsamples_ch = Channel.fromPath(TRIMSAMPLES.sort())
diff --git a/workflows/simulatetrim.nf b/workflows/simulatetrim.nf
index 5da5d113..8dff86ff 100644
--- a/workflows/simulatetrim.nf
+++ b/workflows/simulatetrim.nf
@@ -23,8 +23,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired' || PAIRED == 'singlecell'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         a="Trimming_report.txt"
         b=file(r1).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
         c=file(r2).getName().replace(".fastq.gz", "_trimmed.fastq.gz")
diff --git a/workflows/spit_DTU.nf b/workflows/spit_DTU.nf
index 76c0f0c8..7caae2d4 100644
--- a/workflows/spit_DTU.nf
+++ b/workflows/spit_DTU.nf
@@ -146,7 +146,7 @@ workflow DTU{
     main:
     
     TRIMSAMPLES = LONGSAMPLES.collect{
-            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}*.fastq.gz"
+            element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}*.fastq.gz"
         }
 
     trimsamples_ch =  Channel.fromPath(TRIMSAMPLES.sort())
diff --git a/workflows/star.nf b/workflows/star.nf
index 1ce6d533..6d42b9d8 100644
--- a/workflows/star.nf
+++ b/workflows/star.nf
@@ -93,8 +93,9 @@ process star_mapping{
     idx = reads[0]
     idxdir = idx.toRealPath()
     if (PAIRED == 'paired'){
-        r1 = reads[1]
-        r2 = reads[2]
+        rds = sort_reads(reads[1..2])
+        r1 = rds[0]
+        r2 = rds[1]
         a = "Trimming_report.txt"
         fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
         of = fn+'.Aligned.out.sam'
@@ -114,6 +115,7 @@ process star_mapping{
             """
         }
         else{
+            rds = sort_reads(reads[1..2])
             if (STRANDED == 'fr'){
                 stranded = '--soloStrand Forward'
             }else if (STRANDED == 'rf'){
@@ -121,9 +123,9 @@ process star_mapping{
             }else{
                 stranded = '--soloStrand Unstranded'
             }
-            r1 = reads[1]
+            r1 = rds[0]
             fn = file(r1).getSimpleName().replaceAll(/_R1(_dedup)?_trimmed$/,"")
-            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(reads[2]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
+            r2 = "${workflow.workDir}/../FASTQ/${CONDITION}/"+file(rds[1]).getSimpleName().replaceAll(/\QR2_trimmed\E/,"R2.fastq.gz")
             if (MAPPARAMS.contains('--soloBarcodeMate 1')){
                 t = r2
                 r2 = r1
diff --git a/workflows/starfusion.nf b/workflows/starfusion.nf
index d17a7f73..1a9c1586 100644
--- a/workflows/starfusion.nf
+++ b/workflows/starfusion.nf
@@ -68,7 +68,7 @@ process starfusion_fastq{
     ref = fls[0]
     anno = fls[1]
     if (PAIRED == 'paired'){
-        rs = fls[2..3].sort{ it.getName() }
+        rs = sort_reads(fls[2..3])
         reads = "--left_fq "+rs[0]+" --right_fq "+rs[1]
         fn = file(rs[0]).getSimpleName().replaceAll(/_R[12]_trimmed/, "")
     } else{
@@ -94,7 +94,7 @@ workflow FUSIONS{
     if (FUSFASTQ){
         if (PAIRED == 'paired'){
             TRIMSAMPLES = LONGSAMPLES.collect{
-                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R2,R1}_trimmed.fastq.gz"
+                element -> return "${workflow.workDir}/../TRIMMED_FASTQ/${COMBO}/"+element+"_{R1,R2}_trimmed.fastq.gz"
             }
         } else{
             TRIMSAMPLES = LONGSAMPLES.collect{
diff --git a/workflows/trimgalore.nf b/workflows/trimgalore.nf
index 3f0b80ed..0d980959 100644
--- a/workflows/trimgalore.nf
+++ b/workflows/trimgalore.nf
@@ -28,8 +28,9 @@ process trim{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = reads[0]
-        r2 = reads[1]
+        rds = sort_reads(reads)
+        r1 = rds[0]
+        r2 = rds[1]
         """
         $TRIMBIN --cores ${task.cpus} --paired --gzip $TRIMPARAMS $r1 $r2 &> trim.log && rename 's/_dedup//g' *.fq.gz && rename 's/_R([1|2])_val_([1|2]).fq.gz/_R\\1_trimmed.fastq.gz/g' *.fq.gz && rename 's/.fastq.gz_trimming/_trimming/g' *.txt
         """
diff --git a/workflows/umicollapse.nf b/workflows/umicollapse.nf
index d109297f..588e29b5 100644
--- a/workflows/umicollapse.nf
+++ b/workflows/umicollapse.nf
@@ -29,15 +29,17 @@ process whitelist{
 
     script:    
     if (WHITELISTPARAMS == ''){    
-        outf = samples[0].getSimpleName().replace("_R1","")+"_dummy_whitelist"
+        smpls = sort_reads(samples)
+        outf = smpls[0].getSimpleName().replace("_R1","")+"_dummy_whitelist"
         """
         touch $outf
         """
     } else {
         if (PAIRED == 'paired'){
-            r1 = samples[0]
-            r2 = samples[1]
-            outf = samples[0].getSimpleName().replace("_R1","")+"_whitelist"
+            smpls = sort_reads(samples)
+            r1 = smpls[0]
+            r2 = smpls[1]
+            outf = smpls[0].getSimpleName().replace("_R1","")+"_whitelist"
             """
                 mkdir tmp && umi_tools whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$r1 --read2-in=$r2 --stdout=$outf
             """
@@ -75,10 +77,11 @@ process extract_fq{
 
     script:
     if (PAIRED == 'paired'){
-        r1 = samples[0]
-        r2 = samples[1]
-        outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
-        outf2 = samples[1].getSimpleName()+"_dedup.fastq.gz"
+        smpls = sort_reads(samples)
+        r1 = smpls[0]
+        r2 = smpls[1]
+        outf = smpls[0].getSimpleName()+"_dedup.fastq.gz"
+        outf2 = smpls[1].getSimpleName()+"_dedup.fastq.gz"
         if (!!(wl =~ /dummy_whitelist/)){
             """
                 mkdir tmp && umi_tools extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2
diff --git a/workflows/umicollapse_dedup.nf b/workflows/umicollapse_dedup.nf
index fe84cdfa..64b539a6 100644
--- a/workflows/umicollapse_dedup.nf
+++ b/workflows/umicollapse_dedup.nf
@@ -8,6 +8,8 @@ process dedup_bam{
     container "oras://jfallmann/monsda:"+"$DEDUPENV"
     cpus 1
 	cache 'lenient'
+    memory { 20.GB * (1 << ((task.attempt ?: 1) - 1)) }
+    time { 8.h * (1 << ((task.attempt ?: 1) - 1)) }
     //validExitStatus 0,1
 
     publishDir "${workflow.workDir}/../" , mode: 'link',
@@ -27,9 +29,6 @@ process dedup_bam{
     path "*_dedup.bam.bai", emit: bai
     path "*_dedup.log", emit: logs
 
-    memory { 20.GB * (1 << ((task.attempt ?: 1) - 1)) }
-    time { 8.h * (1 << ((task.attempt ?: 1) - 1)) }
-
     script:
     bams = todedup[0]
     bais = todedup[1]
diff --git a/workflows/umitools.nf b/workflows/umitools.nf
index 3f918bbd..14de6641 100644
--- a/workflows/umitools.nf
+++ b/workflows/umitools.nf
@@ -26,15 +26,17 @@ process whitelist{
 
     script:    
     if (WHITELISTPARAMS == ''){    
-        outf = samples[0].getSimpleName().replace("_R1","")+"_dummy_whitelist"
+        smpls = sort_reads(samples)
+        outf = smpls[0].getSimpleName().replace("_R1","")+"_dummy_whitelist"
         """
         touch $outf
         """
     } else {
         if (PAIRED == 'paired'){
-            r1 = samples[0]
-            r2 = samples[1]
-            outf = samples[0].getSimpleName().replace("_R1","")+"_whitelist"
+            smpls = sort_reads(samples)
+            r1 = smpls[0]
+            r2 = smpls[1]
+            outf = smpls[0].getSimpleName().replace("_R1","")+"_whitelist"
             """
                 mkdir tmp && $DEDUPBIN whitelist $WHITELISTPARAMS --temp-dir tmp --log=wl.log --stdin=$r1 --read2-in=$r2 --stdout=$outf
             """
@@ -73,10 +75,11 @@ process extract_fq{
     script:
     if (EXTRACTPARAMS == ''){
         if (PAIRED == 'paired'){
-            r1 = samples[0]
-            r2 = samples[1]
-            outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
-            outf2 = samples[1].getSimpleName()+"_dedup.fastq.gz"
+            smpls = sort_reads(samples)
+            r1 = smpls[0]
+            r2 = smpls[1]
+            outf = smpls[0].getSimpleName()+"_dedup.fastq.gz"
+            outf2 = smpls[1].getSimpleName()+"_dedup.fastq.gz"
             """
                 echo 'EXTRACT unset, linking input fastq(s) as-is' > ex.log
                 ln -sf \$(readlink -f $r1) $outf
@@ -92,10 +95,11 @@ process extract_fq{
         }
     }
     else if (PAIRED == 'paired'){
-        r1 = samples[0]
-        r2 = samples[1]
-        outf = samples[0].getSimpleName()+"_dedup.fastq.gz"
-        outf2 = samples[1].getSimpleName()+"_dedup.fastq.gz"
+        smpls = sort_reads(samples)
+        r1 = smpls[0]
+        r2 = smpls[1]
+        outf = smpls[0].getSimpleName()+"_dedup.fastq.gz"
+        outf2 = smpls[1].getSimpleName()+"_dedup.fastq.gz"
         if (!!(wl =~ /dummy_whitelist/)){
             """
                 mkdir tmp && $DEDUPBIN extract $EXTRACTPARAMS --temp-dir tmp --log=ex.log --stdin=$r1 --read2-in=$r2 --stdout=$outf --read2-out=$outf2

From 90bd7888b584186a8e30b2b568593fd9ac65b92e Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 8 Oct 2026 20:49:02 +0200
Subject: [PATCH 75/80] unified cutoffs across all differential workflows

---
 MONSDA/Params.py                              | 31 +++++++++++++++----
 MONSDA/Workflows.py                           |  2 +-
 configs/template_base_commented.json          |  8 ++---
 configs/template_clean.json                   |  8 ++---
 tests/data/config_DTU_test.json               |  2 +-
 tests/data/config_Test.json                   |  8 ++---
 tests/data/config_Test_local.json             |  8 ++---
 ...lore-picard-star_DTU_dexseq_subconfig.json |  2 +-
 ...ore-picard-star_DTU_drimseq_subconfig.json |  2 +-
 ...galore-picard-star_DTU_spit_subconfig.json |  2 +-
 ...lore-picard-star_DTU_dexseq_subconfig.json |  2 +-
 ...galore-picard-star_DTU_dexseq_subsnake.smk |  4 +--
 ...ore-picard-star_DTU_drimseq_subconfig.json |  2 +-
 ...alore-picard-star_DTU_drimseq_subsnake.smk |  2 +-
 ...galore-picard-star_DTU_spit_subconfig.json |  2 +-
 ...imgalore-picard-star_DTU_spit_subsnake.smk |  2 +-
 workflows/deseq2_DE.smk                       |  2 +-
 workflows/dexseq_DEU.smk                      |  2 +-
 workflows/dexseq_DTU.smk                      |  4 +--
 workflows/diego_DAS.smk                       |  2 +-
 workflows/drimseq_DTU.smk                     |  2 +-
 workflows/edger_DAS.smk                       |  2 +-
 workflows/edger_DE.smk                        |  2 +-
 workflows/edger_DEU.smk                       |  2 +-
 workflows/spit_DTU.smk                        |  2 +-
 25 files changed, 63 insertions(+), 44 deletions(-)

diff --git a/MONSDA/Params.py b/MONSDA/Params.py
index b334b045..77be14a6 100644
--- a/MONSDA/Params.py
+++ b/MONSDA/Params.py
@@ -923,7 +923,7 @@ def get_cutoff_as_string(config: dict, subwork: str, cf: str) -> str:
     subwork : str
         workflow part
     cf : str
-        cutoff
+        cutoff, either 'padj' or 'lfc'
 
     Returns
     -------
@@ -931,11 +931,30 @@ def get_cutoff_as_string(config: dict, subwork: str, cf: str) -> str:
         configured cutoffs or defaults
     """
     logid = scriptname + ".get_cutoff: "
-    cutoff = (
-        str(config[subwork]["CUTOFFS"].get(cf))
-        if config[subwork].get("CUTOFFS")
-        else ".05" if cf == "pval" else "1.5"
-    )
+    defaults = {"padj": ".05", "lfc": "1.5"}
+    deprecated = {"padj": ["pvalue", "pval"]}
+    cutoffs = config[subwork].get("CUTOFFS") or dict()
+    cutoff = cutoffs.get(cf)
+    if cutoff is None:
+        for alias in deprecated.get(cf, []):
+            if cutoffs.get(alias) is not None:
+                cutoff = cutoffs[alias]
+                log.warning(
+                    logid
+                    + "CUTOFFS key '"
+                    + alias
+                    + "' in "
+                    + str(subwork)
+                    + " is deprecated, cutoffs are applied to adjusted p-values, please rename it to '"
+                    + cf
+                    + "'"
+                )
+                break
+    if cutoff is None:
+        if cf not in defaults:
+            log.error(logid + "No default cutoff known for " + str(cf))
+        cutoff = defaults.get(cf, "1.5")
+    cutoff = str(cutoff)
     log.info(logid + "CUTOFFS: " + str(cf) + ":" + cutoff)
     return cutoff
 
diff --git a/MONSDA/Workflows.py b/MONSDA/Workflows.py
index 524e469a..4f84d67e 100755
--- a/MONSDA/Workflows.py
+++ b/MONSDA/Workflows.py
@@ -2210,7 +2210,7 @@ def nf_fetch_params(
             compstr = ",".join([i.split(":")[0] for i in comparison.split(",")])
             retconf[x + "COMP"] = comparison
             retconf[x + "COMPS"] = compstr
-            pval = mp.get_cutoff_as_string(config, x, "pval")
+            pval = mp.get_cutoff_as_string(config, x, "padj")
             lfc = mp.get_cutoff_as_string(config, x, "lfc")
             retconf[x + "PVAL"] = pval
             retconf[x + "LFC"] = lfc
diff --git a/configs/template_base_commented.json b/configs/template_base_commented.json
index 951393c8..459376bb 100644
--- a/configs/template_base_commented.json
+++ b/configs/template_base_commented.json
@@ -478,7 +478,7 @@
       ]
     },
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "deseq2": {
@@ -516,7 +516,7 @@
       ]
     },
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "dexseq": {
@@ -554,7 +554,7 @@
       ]
     },
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "diego": {
@@ -593,7 +593,7 @@
       ]
     },
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "drimseq": {
diff --git a/configs/template_clean.json b/configs/template_clean.json
index 903d7abe..30130015 100644
--- a/configs/template_clean.json
+++ b/configs/template_clean.json
@@ -306,7 +306,7 @@
     },
     "EXCLUDE": [],
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "id": {
@@ -345,7 +345,7 @@
     },
     "EXCLUDE": [],
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "id": {
@@ -386,7 +386,7 @@
     },
     "EXCLUDE": [],
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "id": {
@@ -428,7 +428,7 @@
     },
     "EXCLUDE": [],
     "CUTOFFS": {
-      "pvalue": "0.05",
+      "padj": "0.05",
       "lfc": "1.5"
     },
     "id": {
diff --git a/tests/data/config_DTU_test.json b/tests/data/config_DTU_test.json
index c990a099..b46536e1 100644
--- a/tests/data/config_DTU_test.json
+++ b/tests/data/config_DTU_test.json
@@ -87,7 +87,7 @@
             "spit": "Analysis/DTU/SPIT.py"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {
diff --git a/tests/data/config_Test.json b/tests/data/config_Test.json
index e15f6af3..83585270 100644
--- a/tests/data/config_Test.json
+++ b/tests/data/config_Test.json
@@ -166,7 +166,7 @@
             "edger": "Analysis/DE/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {
@@ -216,7 +216,7 @@
             "edger": "Analysis/DEU/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
@@ -235,7 +235,7 @@
             "edger": "Analysis/DAS/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
@@ -254,7 +254,7 @@
             "drimseq": "Analysis/DTU/DRIMSEQ.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
diff --git a/tests/data/config_Test_local.json b/tests/data/config_Test_local.json
index 5b6a4709..4618922b 100644
--- a/tests/data/config_Test_local.json
+++ b/tests/data/config_Test_local.json
@@ -158,7 +158,7 @@
             "edger": "Analysis/DE/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {
@@ -208,7 +208,7 @@
             "edger": "Analysis/DEU/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
@@ -227,7 +227,7 @@
             "edger": "Analysis/DAS/EDGER.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
@@ -246,7 +246,7 @@
             "drimseq": "Analysis/DTU/DRIMSEQ.R"
         },
         "CUTOFFS": {
-            "pvalue": "0.05",
+            "padj": "0.05",
             "lfc": "1.5"
         },
         "COMPARABLE": {},
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
index 7fa2c131..ad6d9e55 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
index 86f58007..3a56c93a 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
index db11a2f9..0361b9b8 100644
--- a/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
+++ b/tests/golden/config_DTU/nf/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
index 7fa2c131..ad6d9e55 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
index 67c46693..85cdcbcb 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_dexseq_subsnake.smk
@@ -434,7 +434,7 @@ rule run_DTU:
             outdir = 'DTU/'+combo,
             ref = os.path.abspath(ANNOTATION),
             dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
-            # pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+            # pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             # lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
     shell: "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
 # rule filter_significant:
@@ -445,7 +445,7 @@ rule run_DTU:
 #     log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
 #     conda:  "<REPO>/envs/"+DTUENV+".yaml"
 #     threads: 1
-#     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+#     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
 #             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
 #     shell: "set +o pipefail; for i in {input};do fn=\"${{i##*/}}\"; if [[ -s \"$i\" ]]; then zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane ' next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/SigUP_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn; else touch DTU/{combo}/Sig_$fn DTU/{combo}/SigUP_$fn DTU/{combo}/SigDOWN_$fn; fi; done 2> {log}"
 rule create_summary_snippet:
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
index 86f58007..3a56c93a 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
index 8e53f1a1..65efbd2f 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_drimseq_subsnake.smk
@@ -465,7 +465,7 @@ rule filter_significant_drimseq:
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
index db11a2f9..0361b9b8 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subconfig.json
@@ -13,7 +13,7 @@
     },
     "CUTOFFS": {
       "lfc": "1.5",
-      "pvalue": "0.05"
+      "padj": "0.05"
     },
     "Test": {
       "dexseq": {
diff --git a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
index 93d3442b..871724fe 100644
--- a/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
+++ b/tests/golden/config_DTU/smk/allconditions_fastqc-trimgalore-picard-star_DTU_spit_subsnake.smk
@@ -459,7 +459,7 @@ rule filter_significant_spit:
     conda:  "<REPO>/envs/"+DTUENV+".yaml"
     container: "oras://ghcr.io/jfallmann/monsda:"+DTUENV+""+"-VERSION"
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/deseq2_DE.smk b/workflows/deseq2_DE.smk
index 792bc2f9..38e1048e 100644
--- a/workflows/deseq2_DE.smk
+++ b/workflows/deseq2_DE.smk
@@ -91,7 +91,7 @@ rule filter_significant:
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DE', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DE', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc'),
             bins = BINS
     shell: "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/dexseq_DEU.smk b/workflows/dexseq_DEU.smk
index 4cd28290..fef0af80 100644
--- a/workflows/dexseq_DEU.smk
+++ b/workflows/dexseq_DEU.smk
@@ -98,7 +98,7 @@ rule filter_significant:
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DEU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DEU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/dexseq_DTU.smk b/workflows/dexseq_DTU.smk
index 5a429f78..b200c2c3 100644
--- a/workflows/dexseq_DTU.smk
+++ b/workflows/dexseq_DTU.smk
@@ -41,7 +41,7 @@ rule run_DTU:
             outdir = 'DTU/'+combo,
             ref = os.path.abspath(ANNOTATION),
             dtuopt = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'DTU', DTUENV)['OPTIONS'].get('DTU', "")
-            # pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+            # pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             # lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
     shell: "Rscript --no-environ --no-restore --no-save {params.bins} {input.anno} {params.ref} {params.outdir} {params.compare} {params.pcombo} {threads} \'{params.dtuopt}\' 2> {log}"
 
@@ -53,7 +53,7 @@ rule run_DTU:
 #     log:    expand("LOGS/{combo}_{scombo}_{comparison}/DTU/dexseq/filter_drimseq.log", combo=combo, scombo=scombo, comparison=compstr)
 #     conda:  ""+DTUENV+".yaml"
 #     threads: 1
-#     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pval'),
+#     params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
 #             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc')
 #     shell: "set +o pipefail; for i in {input};do fn=\"${{i##*/}}\"; if [[ -s \"$i\" ]]; then zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane ' next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut} ||$F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] >= {params.lfc_cut})){{print}}' |gzip > DTU/{combo}/SigUP_$fn && zcat $i| grep -v -w 'NA'|perl -F\'\\t\' -wlane 'next if (!$F[1] || !$F[2]);if ($F[1] =~ /adj_pvalue/ || $F[1] < {params.pv_cut} && ($F[2] <= -{params.lfc_cut})){{print}}' |gzip > DTU/{combo}/Sig_$fn; else touch DTU/{combo}/Sig_$fn DTU/{combo}/SigUP_$fn DTU/{combo}/SigDOWN_$fn; fi; done 2> {log}"
 
diff --git a/workflows/diego_DAS.smk b/workflows/diego_DAS.smk
index dec4409c..8d66fab2 100644
--- a/workflows/diego_DAS.smk
+++ b/workflows/diego_DAS.smk
@@ -98,7 +98,7 @@ rule filter_significant:
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DAS', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DAS', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc'),
             bins = BINS
     shell: "set +o pipefail; arr=({input.csv}); orr=({output.sig}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --flag-column significant --flag-value yes --input \"$a\" --output-sig \"${{orr[$i]}}\"; else touch \"${{orr[$i]}}\"; fi; done 2> {log}"
diff --git a/workflows/drimseq_DTU.smk b/workflows/drimseq_DTU.smk
index 4fc06da5..d0020c58 100644
--- a/workflows/drimseq_DTU.smk
+++ b/workflows/drimseq_DTU.smk
@@ -73,7 +73,7 @@ rule filter_significant_drimseq:
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column adj_pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/edger_DAS.smk b/workflows/edger_DAS.smk
index 0761ec9e..39aef066 100644
--- a/workflows/edger_DAS.smk
+++ b/workflows/edger_DAS.smk
@@ -82,7 +82,7 @@ rule filter_significant_edger:
     conda:  ""+DASENV+".yaml"
     container: "oras://jfallmann/monsda:"+DASENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DAS', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DAS', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DAS', 'lfc'),
             bins = BINS
     shell: "set +o pipefail; arr=({input.sort}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/edger_DE.smk b/workflows/edger_DE.smk
index 586d755a..c5cf6699 100644
--- a/workflows/edger_DE.smk
+++ b/workflows/edger_DE.smk
@@ -89,7 +89,7 @@ rule filter_significant:
     conda:  ""+DEENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DE', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DE', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DE', 'lfc'),
             bins = BINS
     shell: "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column log2FoldChange --adjusted-p-column padj --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/edger_DEU.smk b/workflows/edger_DEU.smk
index d5b9a3e8..b4f38bbd 100644
--- a/workflows/edger_DEU.smk
+++ b/workflows/edger_DEU.smk
@@ -81,7 +81,7 @@ rule filter_significant:
     conda:  ""+DEUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DEUENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DEU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DEU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DEU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.tbl}); orr=({output.sig}); orrt=({output.sig_d}); orrr=({output.sig_u}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column logFC --adjusted-p-column FDR --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orrr[$i]}}\" --output-down \"${{orrt[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrt[$i]}}\" \"${{orrr[$i]}}\"; fi;done 2> {log}"
diff --git a/workflows/spit_DTU.smk b/workflows/spit_DTU.smk
index 3871b00f..5e53d992 100644
--- a/workflows/spit_DTU.smk
+++ b/workflows/spit_DTU.smk
@@ -67,7 +67,7 @@ rule filter_significant_spit:
     conda:  ""+DTUENV+".yaml"
     container: "oras://jfallmann/monsda:"+DTUENV+""
     threads: 1
-    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'pvalue'),
+    params: pv_cut = get_cutoff_as_string(config, 'DTU', 'padj'),
             lfc_cut = get_cutoff_as_string(config, 'DTU', 'lfc'),
             bins = BINS
     shell:  "set +o pipefail; arr=({input.res_g}); arrt=({input.res_t}); orr=({output.sig_g}); orrd=({output.sig_dg}); orru=({output.sig_ug}); orrt=({output.sig_t}); orrtd=({output.sig_dt}); orrtu=({output.sig_ut}); for i in \"${{!arr[@]}}\"; do a=\"${{arr[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orr[$i]}}\" --output-up \"${{orru[$i]}}\" --output-down \"${{orrd[$i]}}\"; else touch \"${{orr[$i]}}\" \"${{orrd[$i]}}\" \"${{orru[$i]}}\"; fi;done; for i in \"${{!arrt[@]}}\"; do a=\"${{arrt[$i]}}\"; if [[ -s \"$a\" ]];then python3 {params.bins}/Analysis/filter_significant.py --effect-column lfc --adjusted-p-column pvalue --p-cutoff {params.pv_cut} --lfc-cutoff {params.lfc_cut} --input \"$a\" --output-sig \"${{orrt[$i]}}\" --output-up \"${{orrtu[$i]}}\" --output-down \"${{orrtd[$i]}}\"; else touch \"${{orrt[$i]}}\" \"${{orrtd[$i]}}\" \"${{orrtu[$i]}}\"; fi;done 2> {log}"

From de7ee8385d4c4bd93631aba6009c50eff78cee97 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Thu, 8 Oct 2026 21:13:11 +0200
Subject: [PATCH 76/80] bisulfite env fix

---
 MONSDA/Versions.py                | 6 +++++-
 workflows/segemehl3_bisulfite.smk | 6 +++---
 workflows/segemehl_bisulfite.smk  | 6 +++---
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/MONSDA/Versions.py b/MONSDA/Versions.py
index ec24b8e1..47d5b3dc 100644
--- a/MONSDA/Versions.py
+++ b/MONSDA/Versions.py
@@ -151,7 +151,11 @@ def env_yaml(env, step, envdir):
     str or None
         path to yaml file
     """
-    for name in [env, "_".join([env, step]), "_".join([env, str(step).lower()])]:
+    names = [env, "_".join([env, step]), "_".join([env, str(step).lower()])]
+    # bisulfite mapping runs out of the plain mapper env, see segemehl_bisulfite.smk
+    if "segemehl" in env and "bisulfite" in env:
+        names.append(env.replace("bisulfite", ""))
+    for name in names:
         path = os.path.join(envdir, name + ".yaml")
         if os.path.isfile(path):
             return path
diff --git a/workflows/segemehl3_bisulfite.smk b/workflows/segemehl3_bisulfite.smk
index 2551b9df..6adb9d7b 100644
--- a/workflows/segemehl3_bisulfite.smk
+++ b/workflows/segemehl3_bisulfite.smk
@@ -13,7 +13,7 @@ rule generate_index:
             uidx2 = expand("{refd}/INDICES/{mape}_{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik+'_bs')
     log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-    container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+    container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
     threads: MAXTHREAD
     params: indexer = MAPPERBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
@@ -33,7 +33,7 @@ if paired == 'paired':
                 unmapped2 = "UNMAPPED/{combo}/{file}_R2_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-        container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+        container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp=MAPPERBIN
@@ -48,7 +48,7 @@ else:
                 unmapped = "UNMAPPED/{combo}/{file}_unmapped.fastq.gz"
         log:    "LOGS/{combo}/{file}/MAPPING/segemehl3/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-        container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+        container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp=MAPPERBIN
diff --git a/workflows/segemehl_bisulfite.smk b/workflows/segemehl_bisulfite.smk
index 71233ad4..b702979f 100644
--- a/workflows/segemehl_bisulfite.smk
+++ b/workflows/segemehl_bisulfite.smk
@@ -13,7 +13,7 @@ rule generate_index:
             uidx2 = expand("{refd}/INDICES/{mape}_{unikey}.idx2", refd=REFDIR, mape=MAPPERENV, unikey=unik+'_bs')
     log:    expand("LOGS/{sets}/MAPPING/{mape}/idx.log", sets=SETS, mape=MAPPERENV)
     conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-    container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+    container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
     threads: MAXTHREAD
     params: indexer = MAPPERBIN,
             ipara = lambda wildcards, input: tool_params(SAMPLES[0], None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('INDEX', ""),
@@ -34,7 +34,7 @@ if paired == 'paired':
                 tmpmap = temp("MAPPED/{combo}/{file}_temp.sam")
         log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-        container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+        container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp=MAPPERBIN
@@ -51,7 +51,7 @@ else:
                 tmpmap = temp("MAPPED/{combo}/{file}_temp.sam")
         log:    "LOGS/{combo}/{file}/MAPPING/segemehl/mapping.log"
         conda:  ""+MAPPERENV.replace('bisulfite', '')+".yaml"
-        container: "oras://jfallmann/monsda:"+MAPPERENV+".replace('bisulfite','')"
+        container: "oras://jfallmann/monsda:"+MAPPERENV.replace('bisulfite', '')
         threads: MAXTHREAD
         params: mpara = lambda wildcards: tool_params(wildcards.file, None, config, 'MAPPING', MAPPERENV)['OPTIONS'].get('MAP', ""),
                 mapp=MAPPERBIN

From 95b462fd6f3970ecc790676cabf5ebecbcfb7776 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 9 Oct 2026 07:58:34 +0200
Subject: [PATCH 77/80] logging scaling factors for spike-normalized samples

---
 scripts/Analysis/DE/DESEQ2.R       | 1 +
 scripts/Analysis/DE/EDGER.R        | 4 ++++
 scripts/Analysis/DE/EDGER_no_rep.R | 4 ++++
 scripts/lib/_lib.R                 | 9 +++++++++
 4 files changed, 18 insertions(+)

diff --git a/scripts/Analysis/DE/DESEQ2.R b/scripts/Analysis/DE/DESEQ2.R
index 51f5bad4..48059a43 100755
--- a/scripts/Analysis/DE/DESEQ2.R
+++ b/scripts/Analysis/DE/DESEQ2.R
@@ -274,6 +274,7 @@ for (contrast in comparison) {
         # normalized results, the W_1 covariate alone only adjusts for unwanted variation, not scale.
         dds_norm <- DESeqDataSetFromMatrix(countData = counts(counts_norm), colData = sampleData_norm, design = design_norm)
         dds_norm <- estimateSizeFactors(dds_norm, controlGenes = ctrl_idx)
+        write_scaling_log(sizeFactors(dds_norm), colnames(dds_norm), paste("Tables/DE", "DESEQ2", combi, contrast_name, "table", "scaling.log", sep = "_"))
         dds_norm <- dds_norm[!ctrl_idx, ] # drop spike-ins from testing, size factors are retained
 
         # filter low counts
diff --git a/scripts/Analysis/DE/EDGER.R b/scripts/Analysis/DE/EDGER.R
index 2365d117..782a98b9 100755
--- a/scripts/Analysis/DE/EDGER.R
+++ b/scripts/Analysis/DE/EDGER.R
@@ -282,6 +282,10 @@ for (contrast in comparison) {
         dge_spike <- calcNormFactors(DGEList(counts = spike_counts), method = "TMM")
         dge_norm$samples$norm.factors <- dge_spike$samples$norm.factors
 
+        eff_lib_norm <- dge_norm$samples$lib.size * dge_norm$samples$norm.factors
+        scaling_factors <- eff_lib_norm / exp(mean(log(eff_lib_norm)))
+        write_scaling_log(scaling_factors, dge_norm$samples$samples, paste("Tables/DE", "EDGER", combi, contrast_name, "table", "scaling.log", sep = "_"))
+
         ## create file normalized table
         tmm_norm <- as.data.frame(cpm(dge_norm))
         colnames(tmm_norm) <- t(dge_norm$samples$samples)
diff --git a/scripts/Analysis/DE/EDGER_no_rep.R b/scripts/Analysis/DE/EDGER_no_rep.R
index 199085a2..1557eb4b 100755
--- a/scripts/Analysis/DE/EDGER_no_rep.R
+++ b/scripts/Analysis/DE/EDGER_no_rep.R
@@ -196,6 +196,10 @@ for (contrast in comparison) {
         dge_spike <- calcNormFactors(DGEList(counts = spike_counts), method = "TMM")
         dge_norm$samples$norm.factors <- dge_spike$samples$norm.factors
 
+        eff_lib_norm <- dge_norm$samples$lib.size * dge_norm$samples$norm.factors
+        scaling_factors <- eff_lib_norm / exp(mean(log(eff_lib_norm)))
+        write_scaling_log(scaling_factors, dge_norm$samples$samples, paste("Tables/DE", "EDGER", combi, contrast_name, "table", "scaling.log", sep = "_"))
+
         ## create file normalized table
         tmm_norm <- as.data.frame(cpm(dge_norm))
         colnames(tmm_norm) <- t(dge_norm$samples$samples)
diff --git a/scripts/lib/_lib.R b/scripts/lib/_lib.R
index e1ae4921..f4a21765 100644
--- a/scripts/lib/_lib.R
+++ b/scripts/lib/_lib.R
@@ -184,6 +184,15 @@ lfc_global_shift <- function(lfc) {
     median(vals)
 }
 
+## Write the per-sample scaling factor spike-in normalization derived for a
+## contrast (geometric-mean-centered, 1 = no rescaling relative to the other
+## samples in the contrast), so that shift is traceable independent of the DE
+## results table.
+write_scaling_log <- function(scaling_factors, samples, path) {
+    log_df <- data.frame(sample = samples, spikein_scaling_factor = scaling_factors)
+    write.table(log_df, path, sep = "\t", row.names = FALSE, quote = FALSE)
+}
+
 ## Format a DESeq2 results object for export: add gene name and ID, select the
 ## canonical column order by name and append genomic coordinates after Gene_ID.
 ## Shrunk tables carry no stat column; raw (unshrunk) tables append stat last.

From b77efffd031d1cbcccd5fab5672765832e105330 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 9 Oct 2026 10:08:12 +0200
Subject: [PATCH 78/80] profile updates for postde

---
 profile_nextflow/nextflow.config  | 6 ++++++
 profile_snakemake/config.v8+.yaml | 4 ++++
 2 files changed, 10 insertions(+)

diff --git a/profile_nextflow/nextflow.config b/profile_nextflow/nextflow.config
index 61d9ba57..6079f069 100644
--- a/profile_nextflow/nextflow.config
+++ b/profile_nextflow/nextflow.config
@@ -33,6 +33,12 @@ profiles {
                 queue  = 'medium'
                 time   = { 18.h * (1 << ((task.attempt ?: 1) - 1)) }
             }
+            withName: 'postde' {
+                memory     = { 24.GB * (1 << ((task.attempt ?: 1) - 1)) }
+                queue      = 'medium'
+                time       = { 6.h  * (1 << ((task.attempt ?: 1) - 1)) }
+                maxRetries = 3
+            }
             withName: 'run_drimseq|run_dexseq|run_spit' {
                 memory = { 40.GB * (1 << ((task.attempt ?: 1) - 1)) }
                 queue  = 'long'
diff --git a/profile_snakemake/config.v8+.yaml b/profile_snakemake/config.v8+.yaml
index d9af2971..7922f675 100755
--- a/profile_snakemake/config.v8+.yaml
+++ b/profile_snakemake/config.v8+.yaml
@@ -27,6 +27,10 @@ set-resources:
     mem_mb: "40000 * (2 ** (attempt - 1))"
     slurm_qos: "medium"
     runtime: "18h"
+  postde:
+    mem_mb: "24000 * (2 ** (attempt - 1))"
+    slurm_qos: "medium"
+    runtime: "6h"
   salmon_index:
     mem_mb: "40000 * (2 ** (attempt - 1))"
   sortsam:

From 619bd012e8caaff9076d08a00590920ba83ff9e5 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 9 Oct 2026 13:57:51 +0200
Subject: [PATCH 79/80] template fix

---
 configs/template_clean.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/configs/template_clean.json b/configs/template_clean.json
index 30130015..698e2132 100644
--- a/configs/template_clean.json
+++ b/configs/template_clean.json
@@ -140,7 +140,7 @@
       }
     }
   },
-  "MAP": {
+  "MAPPING": {
     "TOOLS": {
       "star": "STAR",
       "segemehl3": "segemehl.x",
@@ -504,4 +504,5 @@
             }
         }
     }
+  }
 }

From 17bd587fadaadea3fa96eb86f7980a52c61fdfb2 Mon Sep 17 00:00:00 2001
From: jfallmann <fallmann.joerg@gmail.com>
Date: Fri, 9 Oct 2026 13:58:46 +0200
Subject: [PATCH 80/80] added skill so claude and other agents can pick up
 monsda and know how to apply it

---
 .agents/skills/monsda/SKILL.md                |  80 ++++++++
 .agents/skills/monsda/reference/cli.md        | 112 +++++++++++
 .../skills/monsda/reference/config-guide.md   | 169 +++++++++++++++++
 .agents/skills/monsda/reference/workflows.md  |  39 ++++
 .../skills/monsda/scripts/validate_config.py  | 174 ++++++++++++++++++
 .claude/skills/monsda                         |   1 +
 6 files changed, 575 insertions(+)
 create mode 100644 .agents/skills/monsda/SKILL.md
 create mode 100644 .agents/skills/monsda/reference/cli.md
 create mode 100644 .agents/skills/monsda/reference/config-guide.md
 create mode 100644 .agents/skills/monsda/reference/workflows.md
 create mode 100644 .agents/skills/monsda/scripts/validate_config.py
 create mode 120000 .claude/skills/monsda

diff --git a/.agents/skills/monsda/SKILL.md b/.agents/skills/monsda/SKILL.md
new file mode 100644
index 00000000..1dbd2f57
--- /dev/null
+++ b/.agents/skills/monsda/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: monsda
+description: Use MONSDA (Modular Organizer of Nextflow and Snakemake driven hts Data Analysis) to plan and run HTS/NGS pipelines — QC, trimming, mapping, dedup, counting, tracks, peak calling, DE/DEU/DAS/DTU, circRNA, fusion detection — from a single config.json that MONSDA turns into Snakemake or Nextflow workflows. Use whenever the user wants to analyze FASTQ/BAM sequencing data with this repo, needs a MONSDA config built or edited, needs an experimental design mapped to a condition-tree, or wants to generate/dry-run/execute the resulting workflows instead of doing it by hand.
+---
+
+# MONSDA
+
+MONSDA is a config-driven wrapper: one JSON config describes samples, genomes
+and tool choices; MONSDA compiles it into per-condition Snakemake or Nextflow
+sub-workflows and can run them. Your job as the agent is to turn the user's
+experiment description into a correct config, validate it cheaply before
+spending compute, and only then run it — instead of the user hand-editing
+JSON and guessing at tool names.
+
+Read the reference files below on demand (do not load all of them up front):
+
+- `reference/config-guide.md` — config.json anatomy, condition-tree, OPTIONS/TOOLS, samplesheet shortcut. Read before writing or editing any config.
+- `reference/workflows.md` — available `WORKFLOWS` steps and the tools each one accepts. Read when choosing which steps/tools to enable.
+- `reference/cli.md` — `monsda` / `monsda_configure` CLI flags, the generate-then-dry-run validation recipe, cluster profiles. Read before invoking any command.
+
+## Decision flow
+
+1. **Clarify the experiment, not the tool syntax.** Ask the user (or infer from
+   what they already said): experimental design/conditions, where the
+   FASTQ/BAM files and genome/annotation live, sequencing type (single/paired/
+   single-cell, stranded?), and which analysis steps they want
+   (QC/TRIMMING/MAPPING/DEDUP/COUNTING/TRACKS/PEAKS/DE/DEU/DAS/DTU/CIRCS/
+   FUSIONS). Don't ask about MONSDA internals they aren't expected to know.
+2. **Map the design to a condition-tree** (`ID -> CONDITION -> SETTING`,
+   see `reference/config-guide.md`). This fixes the expected input directory
+   layout (`FASTQ/<ID>/<CONDITION>/...`) and the output tool-key directories.
+3. **Build the config.** Prefer, in order:
+   - If the user has (or can export) a sample table, use the built-in
+     `--samplesheet file.csv` support (`configs/samplesheet_template.csv`
+     shows the columns) instead of hand-writing the nested `SETTINGS` block.
+   - Otherwise copy the closest starting point — `configs/template_clean.json`
+     (empty skeleton) or `configs/tutorial_quick.json` (small worked example)
+     — and edit it. Several other files under `configs/` (`template.json`,
+     `tutorial_toolmix.json`, `tutorial_exhaustive.json`,
+     `tutorial_postprocess.json`) carry trailing `#comments` for human
+     documentation and are **not valid JSON**; read them for explanations but
+     don't copy them as-is — see `reference/config-guide.md` for the full list.
+   - Keep `WORKFLOWS` as a single comma-separated string in the **order**
+     steps should run, and give every listed step a corresponding top-level
+     key (`QC`, `MAPPING`, ...), each with a `TOOLS` map and per-condition
+     `OPTIONS` — MONSDA errors out otherwise.
+   - Set `VERSION` to the exact installed MONSDA version the run will use
+     (`python -c "import MONSDA; print(MONSDA.__version__)"` with the same
+     interpreter/env as the run) — a mismatch aborts the run.
+4. **Validate before executing anything expensive.** Run
+   `scripts/validate_config.py <config.json>` (does structural/JSON checks and
+   cross-checks referenced sample/reference files) and then the
+   generate-only + dry-run recipe in `reference/cli.md` (`monsda --save` then
+   `snakemake -n` / nextflow equivalent on the generated sub-workflows). This
+   catches missing files, bad tool names and condition-tree mistakes without
+   running a single real job.
+5. **Run it.** Only after a clean dry run, execute for real (local, or via a
+   cluster profile — see `reference/cli.md`). Report the actual command used
+   and where outputs land (tool-key directories under e.g. `MAPPING/<id>/
+   <condition>/<combo>/`).
+
+## What this buys the user over doing it by hand
+
+- No need to memorize the condition-tree <-> directory-layout mapping or the
+  per-tool `OPTIONS` schema — you look it up in the reference files.
+- `scripts/validate_config.py` catches config mistakes before a conda env
+  solve or a multi-hour mapping job starts.
+- You generate-and-dry-run (`--save` + `snakemake/nextflow -n`) before
+  committing to a real run, which is the step people skip when working by
+  hand and MONSDA doesn't enforce.
+
+## Notes
+
+- `monsda_configure` is an interactive terminal UI meant for humans; it is
+  not practical to drive from an agent. Build/edit the JSON directly (or via
+  `--samplesheet`) instead of trying to script the TUI.
+- If you are working inside a MONSDA git checkout rather than an installed
+  release, see this repo's `AGENTS.md` for the dev-only gotchas (symlinks
+  under `MONSDA/MONSDA`, PATH for `snakemake`/`nextflow`, golden-file tests).
+  None of that applies to an end user running an installed `monsda`.
diff --git a/.agents/skills/monsda/reference/cli.md b/.agents/skills/monsda/reference/cli.md
new file mode 100644
index 00000000..012a5951
--- /dev/null
+++ b/.agents/skills/monsda/reference/cli.md
@@ -0,0 +1,112 @@
+# CLI and validation recipe
+
+Full docs: `docs/source/runsmk.rst`, `docs/source/cluster.rst`. This covers
+what an agent needs to generate, dry-run, and then execute a config safely.
+
+## Environment
+
+```bash
+conda activate monsda   # or whatever env MONSDA was installed into
+```
+
+`monsda` (Snakemake backend, default) and `monsda --nextflow` both need
+`snakemake`/`nextflow` on PATH respectively; MONSDA aborts immediately if the
+selected engine's binary is missing.
+
+## `monsda` flags that matter for an agent
+
+```
+monsda -c CONFIG.json -d DIRECTORY -j PROCS [options]
+```
+
+- `-c/--config/--configfile CONFIG [CONFIG ...]`: one JSON, or JSON + an
+  extra Nextflow-specific config.
+- `-d/--directory`: the run/project root (where `FASTQ/`, `GENOMES/`,
+  `SubSnakes|SubFlows/`, `JOBS/`, `LOGS/` live or will be created).
+- `-j/--procs`: parallelism, capped by the config's `MAXTHREADS`.
+- `--save`: **generate only** — write the sub-workflow files and the CLI
+  calls to `JOBS/` without executing anything. This is the key step for
+  validating a config cheaply.
+- `-s/--skeleton`: just create the minimal directory hierarchy, no config
+  processing.
+- `--snakemake` (default) / `--nextflow`: pick the execution engine.
+- `-u/--use-conda`: use conda envs (default true).
+- `-l/--unlock`: unlock a Snakemake working directory after an interrupted run.
+- `--clean`: Nextflow work-dir cleanup (`-n` to preview, `-f` to actually delete).
+- `--loglevel {WARNING,ERROR,INFO,DEBUG}`.
+- `--samplesheet FILE`: populate `SETTINGS` from a CSV/TSV when the config
+  lacks one (see `reference/config-guide.md`); writes
+  `<config>_with_settings.json` on first use.
+- `--oras-registry HOST` / `--oras-namespace NAMESPACE`: override the
+  container registry/namespace for ORAS image pulls (defaults
+  `ghcr.io` / `jfallmann/monsda`).
+- `--version`: print and exit.
+
+Additional unrecognized arguments are passed through to Snakemake/Nextflow
+verbatim, e.g. `-n` (Snakemake dry-run), `--omit-from <rule>` (skip a rule and
+everything downstream without removing it from `WORKFLOWS`), `--profile
+<dir>` (cluster profile).
+
+## Validate-before-run recipe (do this before a real execution)
+
+1. Run the repo's lightweight structural check first:
+   `python scripts/validate_config.py CONFIG.json` (see this skill's
+   `scripts/` directory) — catches invalid JSON, missing step blocks, a
+   `VERSION` mismatch, and `SETTINGS`/`REFERENCE`/`ANNOTATION` paths that
+   don't exist on disk, before anything talks to Snakemake/Nextflow.
+2. Generate without executing:
+   ```bash
+   monsda -c CONFIG.json -d DIRECTORY -j 2 --save
+   ```
+   This writes the per-condition sub-workflows (`SubSnakes/*.smk` or
+   `SubFlows/*.nf`) and the exact CLI invocations MONSDA would run into
+   `JOBS/MONSDA.commands`.
+3. Dry-run every generated sub-workflow using the commands recorded in
+   `JOBS/MONSDA.commands`, adding `-n` (Snakemake) — e.g.:
+   ```bash
+   snakemake --snakefile SubSnakes/<name>.smk --configfile <subconfig>.json -n
+   ```
+   For Nextflow, `nextflow run <subflow>.nf -preview` only validates syntax,
+   not the script bodies — a real `-n`-equivalent dry run is not available,
+   so inspect the generated `.nf`/its `params` instead, or do a tiny real run
+   on a minimal subset of samples first.
+4. Fix whatever the dry run reports (commonly `MissingInputException` for
+   files that don't exist yet, or a bad tool/env name) and repeat from step 2
+   before launching the full, real run.
+
+## Running for real
+
+```bash
+monsda -c CONFIG.json -d DIRECTORY -j THREADS --conda-frontend mamba \
+  --conda-prefix PATH_TO_CONDA_ENVS
+```
+
+or, for Nextflow:
+
+```bash
+monsda --nextflow -c CONFIG.json -d DIRECTORY -j THREADS
+```
+
+### On a cluster (SLURM example)
+
+```bash
+monsda -c CONFIG.json -d DIRECTORY -j THREADS --conda-frontend mamba \
+  --profile profile_snakemake --conda-prefix PATH_TO_CONDA_ENVS
+```
+
+```bash
+export NXF_EXECUTOR=slurm
+monsda --nextflow -c CONFIG.json -d DIRECTORY -j THREADS
+```
+
+`profile_snakemake/` and `profile_nextflow/` in this repo ship example
+profiles to adapt.
+
+### Resuming a run while skipping a step
+
+Keep the full original `WORKFLOWS` list (see `reference/config-guide.md`),
+and pass Snakemake's own skip flag instead of editing the config:
+
+```bash
+monsda -c CONFIG.json -d DIRECTORY -j THREADS --omit-from multiqc
+```
diff --git a/.agents/skills/monsda/reference/config-guide.md b/.agents/skills/monsda/reference/config-guide.md
new file mode 100644
index 00000000..ed823c83
--- /dev/null
+++ b/.agents/skills/monsda/reference/config-guide.md
@@ -0,0 +1,169 @@
+# config.json anatomy
+
+Full human docs: `docs/source/config.rst`, `docs/source/conditiontree.rst`,
+`docs/source/preparation.rst`. This is the condensed, agent-facing version.
+
+## Top level
+
+```json
+{
+  "WORKFLOWS": "QC,TRIMMING,MAPPING,DEDUP",
+  "BINS": "",
+  "MAXTHREADS": "20",
+  "VERSION": "1.5.0",
+  "SETTINGS": { ... },
+  "QC": { ... },
+  "TRIMMING": { ... },
+  "MAPPING": { ... },
+  "DEDUP": { ... }
+}
+```
+
+- `WORKFLOWS`: comma-separated step names, in run order. Every step listed
+  here needs a matching top-level key with its own settings, or MONSDA errors.
+  Available steps: see `reference/workflows.md`.
+- `VERSION` must equal the installed `MONSDA.__version__` for the interpreter
+  that will run the job, or the run aborts.
+- `MAXTHREADS` caps `-j` passed on the CLI.
+- `BINS`: path to custom user scripts; advanced/rare, leave `""` otherwise.
+
+### Rerunning on an existing output directory
+
+Keep the **full, original** `WORKFLOWS` list even if you only want to rerun a
+later step (e.g. keep `QC,TRIMMING,MAPPING,DEDUP` even if only `DE` changed).
+The tool-key/`combo` directory name is derived from which stages are listed;
+dropping an earlier stage changes that name and makes existing outputs look
+missing, forcing a full rerun. To skip actually re-executing one rule, add
+Snakemake's own `--omit-from <rule>` on the command line instead of editing
+`WORKFLOWS`.
+
+## The condition-tree (`SETTINGS`)
+
+```
+'ID' -> 'CONDITION' -> 'SETTING' (optional third level)
+```
+
+```json
+"SETTINGS": {
+  "LabA": {
+    "wild-type": {
+      "SAMPLES": ["Sample_1", "Sample_2"],
+      "SEQUENCING": "paired",
+      "REFERENCE": "GENOMES/Dm6/dm6.fa.gz",
+      "ANNOTATION": {
+        "GTF": "GENOMES/Dm6/dm6.gtf.gz",
+        "GFF": "GENOMES/Dm6/dm6.gff3.gz"
+      }
+    }
+  }
+}
+```
+
+- Each leaf of the tree is one independent analysis unit. The tree also
+  dictates the **input** directory layout: `FASTQ/<ID>/<CONDITION>/...`
+  (MONSDA looks one level above the deepest leaf for input, so adding a
+  `SETTING` sub-level for e.g. benchmarking different tool params does not
+  require duplicating the FASTQ files).
+- `SAMPLES`: list of sample basenames, no file extension. For paired-end,
+  list the name once without `_R1`/`_R2` — MONSDA appends those
+  automatically and requires files to end in `_R1.fastq.gz`/`_R2.fastq.gz`
+  (single-end: `<name>.fastq.gz`).
+- `SEQUENCING`: `single`, `paired`, or `singlecell`; optionally append
+  comma-separated strandedness (`rf` or `fr`, see RSeQC `infer_experiment.py`
+  convention) e.g. `"paired,fr"`. Leave strandedness empty if unstranded —
+  MONSDA configures per-tool strandedness flags automatically from this.
+- `REFERENCE` / `ANNOTATION.GTF` / `ANNOTATION.GFF` / `INDEX` / `PREFIX` /
+  `DECOY`: per-condition defaults, can be overridden per workflow step.
+- `GROUPS` / `BATCHES` / `TYPES`: optional, same length as `SAMPLES`, used
+  only by DE/DEU/DAS/DTU design matrices (batch correction, type covariate).
+- `IP`: only for `PEAKS` with CLIP-type protocols (`CLIP`, `iCLIP`, `revCLIP`).
+
+Output directories are named by a derived **tool-key/combo**, e.g.
+`MAPPING/LabA/wild-type/fastqc-cutadapt-star-umitools/`, built from the
+enabled workflow steps + tools so different tool combinations never collide.
+
+## Per-workflow-step blocks
+
+Each step listed in `WORKFLOWS` needs:
+
+```json
+"MAPPING": {
+  "TOOLS": { "star": "STAR" },
+  "LabA": {
+    "wild-type": {
+      "ENV": "star",
+      "BIN": "STAR",
+      "star": {
+        "OPTIONS": {
+          "INDEX": "--some-star-index-flag value",
+          "MAP": "--some-star-mapping-flag value"
+        }
+      }
+    }
+  }
+}
+```
+
+- `TOOLS`: map of `conda-env-name: executable-name` for every tool used in
+  this step (env name usually equals the bioconda package, see `envs/`).
+- `ENV`/`BIN` at the condition level override the step-level default (useful
+  to benchmark two installs of the same tool, or point at a local binary for
+  tools without a conda package, e.g. `guppy`, `dorado`).
+- Inside each tool's block, `OPTIONS` holds one key per sub-step (e.g.
+  `INDEX` vs `MAP` for a mapper) with a **raw command-line string** of extra
+  flags for that tool — exactly as you'd type them, minus anything MONSDA
+  derives automatically (paired/stranded flags, threads). Leave `OPTIONS: {}`
+  if no extra flags are needed; never invent a flag that isn't in the tool's
+  own `--help`.
+- `COMPARABLE` (DE/DEU/DAS/DTU and MACS peak calling): if omitted/empty,
+  MONSDA generates all-vs-all comparisons from `GROUPS`. Otherwise:
+  ```json
+  "COMPARABLE": { "comparison-name": ["Group1", "Group2"] }
+  ```
+
+## Fastest path: samplesheet instead of hand-written SETTINGS
+
+If the user can provide a CSV/TSV, skip writing `SETTINGS` by hand. Columns
+(see `configs/samplesheet_template.csv`):
+
+```
+CONDITION,SAMPLE,GROUP,SEQUENCING,REFERENCE,GTF,GFF,INDEX,PREFIX,DECOY,TYPE,BATCH,IP
+```
+
+`CONDITION` is a `/`-separated path that becomes the condition-tree branch
+(e.g. `FGUMI/WT/dummylevel`). Rows sharing a `CONDITION` are grouped into one
+leaf's `SAMPLES` list; only the first row of a group needs the
+REFERENCE/GTF/GFF/etc. columns filled in. Pass it to `monsda` directly with
+`--samplesheet file.csv` (it populates `SETTINGS` in the given config JSON on
+the first run and writes `<config>_with_settings.json` for reuse), or let
+`monsda_configure --samplesheet file.csv` do it when scaffolding a brand-new
+project.
+
+## PostDE (optional enrichment on top of DE)
+
+Only for the `DE` workflow with `deseq2`/`edger` (not DEU/DAS/DTU). Enabled
+via a top-level `POSTDE` key pointing at a separate analysis JSON (gProfiler/
+clusterProfiler/GSVA/decoupleR/dream). See `docs/source/config.rst` section
+"PostDE" and the shipped example `configs/postde_analysis.json` before
+building one — it has its own schema and conda env (`postde`).
+
+## Starting points in this repo
+
+Valid JSON, safe to copy/parse directly:
+
+- `configs/template_clean.json` — empty skeleton with every workflow step's
+  key already scaffolded.
+- `configs/tutorial_quick.json` — small worked example (FETCH+MAPPING on the
+  bundled `tests/data` Ecoli set).
+- `configs/template_umicollapse.json` — UMI-aware dedup example.
+- `configs/postde_analysis.json` — example PostDE analysis JSON.
+
+**Documentation-only, NOT valid JSON** — these have trailing `#comment`
+annotations after values and will fail `json.load`; read them for the
+explanations but copy structure from the valid files above instead:
+`configs/template.json`, `configs/template_base_commented.json`,
+`configs/tutorial_toolmix.json`, `configs/tutorial_exhaustive.json`,
+`configs/tutorial_postprocess.json`. Strip the `#...` trailing comments
+before using one of these as a base, or diff it against
+`configs/template_clean.json` to see the annotation-free version of the same
+keys.
diff --git a/.agents/skills/monsda/reference/workflows.md b/.agents/skills/monsda/reference/workflows.md
new file mode 100644
index 00000000..4a44ee7e
--- /dev/null
+++ b/.agents/skills/monsda/reference/workflows.md
@@ -0,0 +1,39 @@
+# Workflow steps and tools
+
+Full tables with descriptions/links: `docs/source/workflows.rst`. Condensed
+reference below: `WORKFLOWS` step name -> `conda-env: executable` pairs you
+can put under that step's `TOOLS` key. Env names match a `.yaml` in `envs/`.
+
+| Step | Purpose | `TOOLS` env : bin examples |
+|---|---|---|
+| `FETCH` | Download from SRA | `sra: fasterq-dump` |
+| `BASECALL` | FAST5/POD5 -> FASTQ | `guppy: $PATH_TO_LOCAL_BIN` (no conda pkg), `dorado: $PATH_TO_LOCAL_BIN` (no conda pkg) |
+| `QC` | QC of FASTQ/BAM (runs standalone pre-processing, or again post-processing for any later step) | `fastqc: fastqc` (FASTQ/BAM, includes MultiQC), `rustqc: rustqc` (BAM only, includes MultiQC, has a strandedness guard — aborts the run if inferred strandedness conflicts with `SEQUENCING`) |
+| `TRIMMING` | Adapter/quality trimming | `trimgalore: trim_galore`, `cutadapt: cutadapt`, `bbduk: bbduk`, `fastp: fastp` |
+| `MAPPING` | Align to reference | `hisat2: hisat2`, `star: STAR` (also used for `STARsolo` single-cell mode), `rustar: rustar` (Rust STAR reimplementation), `segemehl2`/`segemehl3`/`segemehl2bisulfite`/`segemehl3bisulfite: segemehl.x`, `bwa: bwa mem`, `bwa2: bwa2-mem`, `bwameth: bwameth.py`, `minimap: minimap2` (long-read, use `-x map-ont`/`-x map-pb` in OPTIONS), `salmonalign: salmon` (alignment mode), `rammap: rammap` (long-read, not on bioconda), `piscem: piscem` (single-cell only, emits RAD for `alevinfry`) |
+| `DEDUP` | Remove/mark duplicates | `umitools: umi_tools`, `fgumi: fgumi` (UMI extraction + dedup), `picard: picard` (position-based) |
+| `COUNTING` | Quantify reads/transcripts | `countreads: featureCounts`, `salmon: salmon` (FASTQ or, via `OPTIONS.BAM = "transcriptome"\|"genome"`, directly from BAM), `kallisto: kallisto`, `oarfish: oarfish` (long-read, from transcriptome BAM), `alevinfry: alevin-fry` (needs a piscem RAD file), `simpleaf: simpleaf` (self-contained single-cell index+map+quant) |
+| `TRACKS` | trackdb.txt + BIGWIG for UCSC/genome browsers | `ucsc: ucsc` |
+| `PEAKS` | Peak calling (ChIP/RIP/CLIP) | `piranha: piranha` (CLIP/RIP), `macs: macs` (ChIP TF binding; use `COMPARABLE` for signal-vs-background pairs), `scyphy: piranha` (cyPhyRNA-Seq), `peaks: peaks` (quick/unpublished window scan) |
+| `DE` | Differential gene expression | `deseq2`, `edger` (R scripts under `Analysis/DE/`) |
+| `DEU` | Differential exon usage | `dexseq`, `edger` |
+| `DAS` | Differential alternative splicing | `edger`, `diego` |
+| `DTU` | Differential transcript usage | `dexseq`, `drimseq`, `spit` (all three accept an optional `TERMINUS` option to pre-group transcripts) |
+| `CIRCS` | circRNA detection | `ciri2: $Path_to_CIRI2.pl` (install locally, no conda pkg) |
+| `FUSIONS` | Fusion gene detection | `starfusion: STAR-Fusion` — needs `MAPPING` with `star` and chimeric output enabled (`--chimSegmentMin 12 --chimOutType Junctions` in the STAR `MAP` OPTIONS), or set `FUSIONS.OPTIONS.FASTQ = "true"` to run directly on trimmed FASTQ instead. Needs a CTAT genome resource dir in `INDEX` (auto-built from `REFERENCE`+`ANNOTATION` if missing — slow). |
+
+Notes:
+
+- QC runs automatically again after any processing step if enabled, in
+  addition to the optional pre-processing QC pass.
+- Single-cell: `piscem` (MAPPING) + `alevinfry` (COUNTING), or the
+  self-contained `simpleaf` (COUNTING only); generic post-mapping QC/DEDUP is
+  skipped for the RAD-file path.
+- Long-read (Nanopore/PacBio): `minimap`/`rammap` (MAPPING) + `oarfish`
+  (COUNTING, from transcriptome BAM).
+- Bisulfite: `bwameth` or `segemehl{2,3}bisulfite` for MAPPING.
+- Tools marked "no conda pkg" need `ENV`/`BIN` pointing at a locally
+  installed executable instead of a bioconda environment name.
+- `PostDE` (gProfiler/clusterProfiler/GSVA/decoupleR/dream enrichment on top
+  of `DE` with `deseq2`/`edger`) is a separate top-level `POSTDE` config, not
+  a `WORKFLOWS` entry — see `reference/config-guide.md`.
diff --git a/.agents/skills/monsda/scripts/validate_config.py b/.agents/skills/monsda/scripts/validate_config.py
new file mode 100644
index 00000000..16c797ff
--- /dev/null
+++ b/.agents/skills/monsda/scripts/validate_config.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Cheap, offline sanity checks for a MONSDA config.json.
+
+This does NOT replace MONSDA's own validation (``monsda --save`` + a
+Snakemake/Nextflow dry run, see reference/cli.md) — it only catches obvious
+mistakes (bad JSON, missing step blocks, a stale VERSION, sample/reference
+files that don't exist) before you spend time on a real generate/run.
+
+Usage:
+    python validate_config.py CONFIG.json [--base DIR]
+
+``--base`` is the run/project directory paths in the config are resolved
+against (defaults to the config file's own directory).
+"""
+import argparse
+import json
+import os
+import sys
+
+KNOWN_WORKFLOW_STEPS = {
+    "FETCH", "BASECALL", "QC", "TRIMMING", "MAPPING", "DEDUP", "COUNTING",
+    "TRACKS", "PEAKS", "DE", "DEU", "DAS", "DTU", "CIRCS", "FUSIONS",
+}
+
+
+def fail(msg, errors):
+    errors.append(msg)
+
+
+def walk_settings_leaves(node, path=()):
+    """Yield (path, leaf_dict) for every SETTINGS leaf that has a SAMPLES key."""
+    if not isinstance(node, dict):
+        return
+    if "SAMPLES" in node:
+        yield path, node
+        return
+    for key, val in node.items():
+        if isinstance(val, dict):
+            yield from walk_settings_leaves(val, path + (key,))
+
+
+def check_installed_version(declared_version, errors, warnings):
+    try:
+        import MONSDA
+        installed = getattr(MONSDA, "__version__", None)
+    except Exception:
+        warnings.append(
+            "Could not import MONSDA to check VERSION against the installed "
+            f"release (declared VERSION={declared_version!r}); verify manually "
+            "with: python -c \"import MONSDA; print(MONSDA.__version__)\""
+        )
+        return
+    if installed and declared_version != installed:
+        fail(
+            f"VERSION in config ({declared_version!r}) does not match the "
+            f"installed MONSDA ({installed!r}). MONSDA refuses to run on a "
+            "mismatch.",
+            errors,
+        )
+
+
+def resolve(base, path):
+    if not path:
+        return None
+    expanded = os.path.expandvars(os.path.expanduser(path))
+    return expanded if os.path.isabs(expanded) else os.path.join(base, expanded)
+
+
+def check_leaf_paths(leaf, base, label, errors, warnings):
+    for key in ("REFERENCE", "INDEX"):
+        val = leaf.get(key)
+        if isinstance(val, str) and val:
+            full = resolve(base, val)
+            if not os.path.exists(full):
+                warnings.append(f"{label}: {key} path not found: {val}")
+    ann = leaf.get("ANNOTATION")
+    if isinstance(ann, dict):
+        for key, val in ann.items():
+            if isinstance(val, str) and val:
+                full = resolve(base, val)
+                if not os.path.exists(full):
+                    warnings.append(f"{label}: ANNOTATION.{key} path not found: {val}")
+    samples = leaf.get("SAMPLES")
+    if not isinstance(samples, list) or not samples:
+        fail(f"{label}: SAMPLES is missing or empty", errors)
+    for extra_key in ("GROUPS", "BATCHES", "TYPES"):
+        extra = leaf.get(extra_key)
+        if extra is not None and isinstance(samples, list) and len(extra) != len(samples):
+            fail(
+                f"{label}: {extra_key} has {len(extra)} entries but SAMPLES "
+                f"has {len(samples)}",
+                errors,
+            )
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("config", help="Path to the MONSDA config JSON")
+    parser.add_argument(
+        "--base", default=None,
+        help="Directory to resolve relative paths against (default: config's own directory)",
+    )
+    args = parser.parse_args()
+
+    errors, warnings = [], []
+
+    try:
+        with open(args.config) as fh:
+            config = json.load(fh)
+    except json.JSONDecodeError as exc:
+        print(f"ERROR: {args.config} is not valid JSON: {exc}", file=sys.stderr)
+        print(
+            "Hint: configs/template.json has trailing '#comments' for "
+            "documentation and is NOT valid JSON on its own; start from "
+            "configs/template_clean.json instead.",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    except OSError as exc:
+        print(f"ERROR: could not read {args.config}: {exc}", file=sys.stderr)
+        sys.exit(2)
+
+    base = args.base or os.path.dirname(os.path.abspath(args.config)) or "."
+
+    for required in ("WORKFLOWS", "VERSION", "SETTINGS"):
+        if required not in config:
+            fail(f"Missing top-level key: {required}", errors)
+
+    workflows_raw = config.get("WORKFLOWS", "")
+    steps = [s.strip() for s in str(workflows_raw).split(",") if s.strip()]
+    if not steps:
+        fail("WORKFLOWS is empty: no workflow step selected", errors)
+    for step in steps:
+        if step not in KNOWN_WORKFLOW_STEPS:
+            warnings.append(
+                f"WORKFLOWS lists {step!r}, which is not in the known step "
+                f"list ({sorted(KNOWN_WORKFLOW_STEPS)}); check reference/workflows.md"
+            )
+        elif step not in config:
+            fail(
+                f"WORKFLOWS includes {step!r} but there is no top-level "
+                f"{step!r} block with its TOOLS/OPTIONS",
+                errors,
+            )
+
+    version = config.get("VERSION")
+    if version is not None:
+        check_installed_version(version, errors, warnings)
+
+    settings = config.get("SETTINGS")
+    if isinstance(settings, dict):
+        leaves = list(walk_settings_leaves(settings))
+        if not leaves:
+            fail("SETTINGS has no condition-tree leaf with a SAMPLES list", errors)
+        for path, leaf in leaves:
+            label = "SETTINGS." + ".".join(path) if path else "SETTINGS"
+            check_leaf_paths(leaf, base, label, errors, warnings)
+
+    print(f"Checked {args.config} (base dir: {base})")
+    if warnings:
+        print(f"\n{len(warnings)} warning(s):")
+        for w in warnings:
+            print(f"  - {w}")
+    if errors:
+        print(f"\n{len(errors)} error(s):")
+        for e in errors:
+            print(f"  - {e}")
+        sys.exit(1)
+    print("\nNo structural errors found. This does not replace a real "
+          "`monsda --save` + dry-run (see reference/cli.md).")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.claude/skills/monsda b/.claude/skills/monsda
new file mode 120000
index 00000000..f0e7e4f8
--- /dev/null
+++ b/.claude/skills/monsda
@@ -0,0 +1 @@
+../../.agents/skills/monsda
\ No newline at end of file