Snakefile

                "ALFA_plots.{annotation}.pdf"),
            unique=["Unique", "UniqueMultiple"],
            annotation=["Categories", "Biotypes"])

    output:
        expand(os.path.join(
            config["output_dir"],
            "ALFA",
            "ALFA_plots.concat.png"))

    params:
        density = 300

    log:
        os.path.join(
            config["log_dir"],
            "alfa_qc_all_samples.concat.log")

    singularity:
        "docker://zavolab/imagemagick:7.0.8"

    shell:
        "(convert -append -density {params.density} \
            {input} {output}) &> {log}"


rule prepare_multiqc_config:
    '''
        Prepare config for the MultiQC
    '''
    input:
        logo_path = os.path.abspath(
            os.path.join(
                "images",
                "logo.128px.png"))

    output:
        multiqc_config = os.path.join(
            config["output_dir"],
            "multiqc_config.yaml")

    log:
        stderr = os.path.join(
            config["log_dir"],
            "prepare_multiqc_config.stderr.log"),
        stdout = os.path.join(
            config["log_dir"],
            "prepare_multiqc_config.stdout.log")

    shell:
        "(python scripts/rhea_multiqc_config.py \
        --config {output.multiqc_config} \
        --custom_logo {input.logo_path}) \
        1> {log.stdout} 2> {log.stderr}"


rule multiqc_report:
    '''
        Create report with MultiQC
    '''
    input:
        fastqc_se = expand(
            os.path.join(
                config['output_dir'],
                "samples",
                "{sample}",
                "fastqc",
                "{mate}"),
            sample=samples_table.index.values,
            mate="fq1"),

        fastqc_pe = expand(
            os.path.join(
                config['output_dir'],
                "samples",
                "{sample}",
                "fastqc",
                "{mate}"),
            sample=[i for i in list(
                samples_table[samples_table['seqmode'] == 'pe'].index.values)],
            mate="fq2"),

        pseudoalignment = expand(
            os.path.join(
                config['output_dir'],
                "samples",
                "{sample}",
                "quant_kallisto",
                "{sample}.{seqmode}.kallisto.pseudo.sam"),
            zip,
            sample=[i for i in list(samples_table.index.values)],
            seqmode=[samples_table.loc[i, 'seqmode']
                     for i in list(samples_table.index.values)]),

        TIN_boxplot_PNG = os.path.join(
            config['output_dir'],
            "TIN_scores_boxplot.png"),

        TIN_boxplot_PDF = os.path.join(
            config['output_dir'],
            "TIN_scores_boxplot.pdf"),

        salmon_merge_genes = expand(
            os.path.join(
                config["output_dir"],
                "summary_salmon",
                "quantmerge",
                "genes_{salmon_merge_on}.tsv"),
            salmon_merge_on=["tpm", "numreads"]),

        salmon_merge_transcripts = expand(
            os.path.join(
                config["output_dir"],
                "summary_salmon",
                "quantmerge",
                "transcripts_{salmon_merge_on}.tsv"),
            salmon_merge_on=["tpm", "numreads"]),

        star_rpm = expand(
            os.path.join(
                config["output_dir"],
                "samples",
                "{sample}",
                "STAR_coverage",
                "{sample}_Signal.UniqueMultiple.str1.out.bg"),
            sample=samples_table.index.values),

        alfa_concat_out = os.path.join(
            config["output_dir"],
            "ALFA",
            "ALFA_plots.concat.png"),

        multiqc_config = os.path.join(
            config["output_dir"],
            "multiqc_config.yaml")

    output:
        multiqc_report = directory(
            os.path.join(
                config["output_dir"],
                "multiqc_summary"))

    params:
        results_dir = os.path.join(
            config["output_dir"]),
        log_dir = config["log_dir"]

    log:
        stderr = os.path.join(
            config["log_dir"],
            "multiqc_report.stderr.log"),
        stdout = os.path.join(
            config["log_dir"],
            "multiqc_report.stdout.log")

    singularity:
        "docker://ewels/multiqc:1.7"

    shell:
        "(multiqc \
        --outdir {output.multiqc_report} \
        --config {input.multiqc_config} \
        {params.results_dir} \
        {params.log_dir};) \
        1> {log.stdout} 2> {log.stderr}"




rule sort_bed_4_big:
    '''
    sort bedGraphs in order to work with bedGraphtobigWig
    '''
    input:
        bg = os.path.join(
            config["output_dir"],
            "samples",
            "{sample}",
            "ALFA",
            "{unique}",
            "{sample}_Signal.{unique}.out.{strand}.bg")
    output:
        sorted_bg = os.path.join(config["output_dir"],
                                "samples",
                                "{sample}",
                                "bigWig",
                                "{unique}",
                                "{sample}_{unique}_{strand}.sorted.bg")
    singularity:
        "docker://cjh4zavolab/bedtools:2.27"
    log:
        stderr = os.path.join(
            config["log_dir"],
            "samples",
            "{sample}",
            "sort_bg_{unique}_{strand}.stderr.log"),
        stdout = os.path.join(
            config["log_dir"],
            "samples",
            "{sample}",
            "sort_bg_{unique}_{strand}.stdout.log")
    shell:
        '''
        sortBed \
        -i {input.bg} \
        > {output.sorted_bg}
        '''

rule prepare_bigWig:
    '''
    bedGraphtobigWig, for viewing in genome browsers
    '''
    input:
        sorted_bg = os.path.join(config["output_dir"],
                                "samples",
                                "{sample}",
                                "bigWig",
                                "{unique}",
                                "{sample}_{unique}_{strand}.sorted.bg"),
        chr_sizes = lambda wildcards: os.path.join(config['star_indexes'],
                            samples_table.loc[wildcards.sample, "organism"], 
                            str(samples_table.loc[wildcards.sample, "index_size"]),
                                "STAR_index",
                                "chrNameLength.txt")
    output:
        bigWig = os.path.join(config["output_dir"],
                                "samples",
                                "{sample}",
                                "bigWig",
                                "{unique}",
                                "{sample}_{unique}_{strand}.bw")
    singularity:
        "docker://zavolab/bedgraphtobigwig:4-slim"
    log:
        stderr = os.path.join(
            config["log_dir"],
            "samples",
            "{sample}",
            "bigwig_{unique}_{strand}.stderr.log"),
        stdout = os.path.join(
            config["log_dir"],
            "samples",
            "{sample}",
            "bigwig_{unique}_{strand}.stdout.log")
    shell:
        '''
        bedGraphToBigWig \
        {input.sorted_bg} \
        {input.chr_sizes} \
        {output.bigWig}
        '''